home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ABUSESRC.ZIP / AbuseSrc / macabuse / src / game.c.new < prev    next >
Encoding:
Text File  |  1997-05-20  |  70.3 KB  |  2,947 lines
  1. #include "idle.hpp"
  2. #include "system.h"
  3. #include "game.hpp"
  4. #include "dev.hpp"
  5. #include "id.hpp"
  6. #include "joy.hpp"
  7. #include "timing.hpp"
  8. #include "help.hpp"
  9. #include "ability.hpp"
  10. #include "cache.hpp"
  11. #include "loader.hpp"
  12. #include "lisp.hpp"
  13. #include "monoprnt.hpp"
  14. #include "jrand.hpp"
  15. #include "config.hpp"
  16. #include "light.hpp"
  17. #include "scroller.hpp"
  18. #include "dprint.hpp"
  19. #include "nfserver.hpp"
  20. #include "video.hpp"
  21. #include "transp.hpp"
  22. #include "clisp.hpp"
  23. #include "guistat.hpp"
  24. #include "menu.hpp"
  25. #include "gamma.hpp"
  26. #include "lisp_gc.hpp"
  27. #include "demo.hpp"
  28. #include "sbar.hpp"
  29. #include "profile.hpp"
  30. #include "compiled.hpp"
  31. #include "lisp_gc.hpp"
  32. #include "pmenu.hpp"
  33. #include "timing.hpp"
  34. #include "chat.hpp"
  35. #include "demo.hpp"
  36. #include "netcfg.hpp"
  37. #include "specache.hpp"
  38. #include "ant.hpp"
  39. #include "netstat.hpp"
  40.  
  41.  
  42. #ifdef __MAC__
  43. //#include <profiler.h>  //prof
  44. #include "macgame.hpp"
  45. #include "macstat.hpp"
  46. #endif
  47.  
  48. #include <ctype.h>
  49. #include <setjmp.h>
  50.  
  51. #define SHIFT_RIGHT_DEFAULT 0
  52. #define SHIFT_DOWN_DEFAULT 30
  53.  
  54. class game;
  55. extern crc_manager *net_crcs;
  56. extern void show_verinfo(int argc, char **argv);
  57. game *the_game;
  58. window_manager *eh=NULL;
  59. int dev,shift_down=SHIFT_DOWN_DEFAULT,shift_right=SHIFT_RIGHT_DEFAULT;
  60. double sum_diffs=1,total_diffs=12;
  61. int total_active=0;
  62. long map_xoff=0,map_yoff=0;
  63. long current_vxadd,current_vyadd;
  64. int frame_panic=0,massive_frame_panic=0;
  65. int demo_start=0,idle_ticks=0;
  66. int req_end=0;
  67.  
  68. extern palette *old_pal;
  69. char **start_argv;
  70. int start_argc;
  71. int has_joystick=0;
  72. char req_name[100];
  73.  
  74. int registered=0;
  75.  
  76. extern int PixMult;
  77.  
  78. extern uchar chatting_enabled;
  79.  
  80. extern int confirm_quit();
  81.  
  82. #ifdef __MAC__
  83. extern char *macify_name(char *s);
  84.  
  85. #if 1
  86. #include "atalk.hpp"
  87. atalk_protocol atalk;
  88.  
  89. #else
  90. #include "tcpip.hpp"
  91.  
  92. tcpip_protocol tcpip;
  93. #endif
  94.  
  95. #endif
  96.  
  97.  
  98. #if !defined (MAC_PROFILE)
  99. #define StartTime(a) (0)
  100. #define DiffTime(a,b) (0)
  101. #else
  102.  
  103. // Timer code
  104. #include <Timer.h> // kill me (us)
  105.  
  106. #define KJCOUNTERS 20
  107. long kjcount[KJCOUNTERS];
  108. char kjfie[KJCOUNTERS][256] = { };  // kill me
  109.  
  110. extern long StartTime(int cnt);         //kill me
  111. extern long DiffTime(char *name, int cnt);   //kill me
  112. extern unsigned lighting_loop_time;
  113.  
  114. long StartTime(int cnt) //kill me too
  115. {
  116.   UnsignedWide t;
  117.   Microseconds(&t);
  118.     
  119.   return (kjcount[cnt] = t.lo);
  120. }
  121.  
  122. long DiffTime(char *name, int cnt) //kill me too
  123. {
  124.   UnsignedWide t;
  125.   Microseconds(&t);
  126.     
  127.   sprintf(kjfie[cnt],"%-16s %8d",name,t.lo-kjcount[cnt]);
  128.     
  129.   return (t.lo-kjcount[cnt]);
  130.  
  131. }
  132. #endif
  133.  
  134. void fade_in(image *im, int steps);
  135. void fade_out(int steps);
  136.  
  137. FILE *open_FILE(char *filename, char *mode)
  138. {
  139.   /*  char *prefix=get_filename_prefix() ? get_filename_prefix() : "",*c;
  140.   
  141.       if (get_save_filename_prefix)
  142.       {
  143.       for (c=mode;*c;c++) 
  144.       if (c=='w' || c=='W') 
  145.       {
  146.       }
  147.       } */
  148.       
  149.   
  150.   char tmp_name[200];
  151.   if (get_filename_prefix())
  152.     sprintf(tmp_name,"%s%s",get_filename_prefix(),filename);
  153.   else strcpy(tmp_name,filename);
  154. #ifdef __MAC__
  155.   macify_name(tmp_name);
  156. #endif
  157.   return fopen(tmp_name,mode);
  158. }
  159.  
  160.  
  161. void handle_no_space()
  162. {
  163.   char *no_space_msg= "\nYou are out of disk space or the game\n"
  164.     "was unable to write to disk for some reason\n"
  165.     "The game cannot continue, please check this out\n"
  166.     "and try again.\n";
  167.   if (eh)
  168.   {
  169.     jwindow *no_space=eh->new_window(0,0,-1,-1,
  170.         new button(WINDOW_FRAME_LEFT,WINDOW_FRAME_TOP,ID_QUIT_OK,"Quit",
  171.             new info_field(WINDOW_FRAME_LEFT,WINDOW_FRAME_TOP+eh->font()->height()*2,ID_NULL,
  172.                 no_space_msg,NULL)),"ERROR");
  173.     event ev;
  174.     do 
  175.     { 
  176.       eh->flush_screen();
  177.       eh->get_event(ev);
  178.     } while (ev.type!=EV_MESSAGE || ev.message.id!=ID_QUIT_OK);
  179.     eh->close_window(no_space);
  180.  
  181.     close_graphics();
  182.     exit(1);
  183.   } else
  184.   {
  185.     dprintf("%s\n",no_space_msg);
  186.     exit(0);
  187.   }
  188. }
  189.  
  190. void game::play_sound(int id, int vol, long x, long y)
  191. {
  192.   if (sound_avail&SFX_INITIALIZED)
  193.   {
  194.     if (vol<15) return ;
  195.     if (!player_list) return ;
  196.  
  197.     ulong mdist=0xffffffff;
  198.     view *cd=NULL;
  199.     for (view *f=player_list;f;f=f->next)
  200.     {
  201.       if (f->local_player())
  202.       {
  203.     long cx=abs(f->x_center()-x),cy=abs(f->y_center()-y),d;
  204.     if (cx<cy)
  205.           d=cx+cy-(cx>>1);
  206.     else d=cx+cy-(cy>>1);
  207.  
  208.     if (d<mdist)
  209.     {
  210.       cd=f;
  211.       mdist=d;
  212.     } 
  213.       }
  214.     }  
  215.     if (mdist>500 || !cd) return ;
  216.     if (mdist<100) mdist=0;
  217.     else mdist-=100;
  218.  
  219.     int v=(400-mdist)*sfx_volume/400-(127-vol);
  220.     if (v>0 && (sound_avail&SFX_INITIALIZED))
  221.       cash.sfx(id)->play(v);
  222.   }
  223. }
  224.  
  225. int get_option(char *name)
  226. {
  227.   int i;
  228.   for (i=1;i<start_argc;i++)
  229.     if (!strcmp(start_argv[i],name))
  230.       return i;
  231.   return 0;
  232. }
  233.  
  234.  
  235. void make_screen_size(int w, int h)
  236. {
  237.   return ;
  238.   /*
  239.   for (view *f=player_list;f;f=f->next)
  240.   {
  241.     if (f->local_player())
  242.     {
  243.       if (w>=xres-1) w=xres-2;
  244.       if (h>=yres-1) h=yres-2;
  245.       f->suggest.cx1=(xres+1)/2-w/2;
  246.       f->suggest.cx2=(xres+1)/2+w/2;
  247.       f->suggest.cy1=(yres-31)/2+5-h/2;
  248.       f->suggest.cy2=(yres-51)/2+5+h/2;
  249.       f->suggest.shift_down=f->shift_down;
  250.       f->suggest.shift_right=f->shift_right;
  251.       f->suggest.pan_x=f->pan_x;
  252.       f->suggest.pan_y=f->pan_y;
  253.  
  254.       f->suggest.send_view=1;
  255.     }
  256.   } */
  257. }
  258.  
  259. void game::grow_views(int amount)
  260. {
  261.   return ;
  262.   /*
  263.   int undo=0;
  264.   view *f=first_view;
  265.   for (;f;f=f->next)
  266.   {
  267.     if (f->local_player())
  268.     {
  269.       f->suggest.cx1=(f->cx1-amount);
  270.       f->suggest.cy1=f->cy1-amount/2;
  271.       f->suggest.cx2=(f->cx2+amount);
  272.       f->suggest.cy2=f->cy2+amount/2;
  273.       f->suggest.shift_down=f->shift_down;
  274.       f->suggest.shift_right=f->shift_right;
  275.       f->suggest.pan_x=f->pan_x;
  276.       f->suggest.pan_y=f->pan_y;
  277.  
  278.       f->suggest.send_view=1;
  279.     }
  280.   }
  281.  
  282.  
  283.   for (f=first_view;f;f=f->next)  
  284.   {
  285.     if (f->local_player())
  286.     {
  287.       if (f->suggest.cx2-f->suggest.cx1<20 || f->suggest.cy2-f->suggest.cy1<15 || 
  288.           f->suggest.cx1<0 || f->suggest.cy1<0) f->suggest.send_view=0;
  289.       if (f->next && f->next->local_player() && f->suggest.cy2>=f->next->cy1) f->suggest.send_view=0;
  290.     }
  291.   } */
  292. }
  293.  
  294. void game::pan(int xv, int yv) 
  295. { 
  296.   first_view->pan_x+=xv; 
  297.   first_view->pan_y+=yv; 
  298. }
  299.  
  300. view *game::view_in(int mousex, int mousey)
  301. {
  302.   for (view *f=first_view;f;f=f->next)
  303.     if (f->drawable() && mousex>=f->cx1 && mousey>=f->cy1 && mousex<=f->cx2 && mousey<=f->cy2)
  304.       return f;
  305.   return NULL;
  306. }
  307.  
  308. int playing_state(int state)
  309. { 
  310.   if (state==RUN_STATE || state==PAUSE_STATE) return 1;
  311.   else return 0;
  312. }
  313.  
  314. void game::ftile_on(int screenx, int screeny, long &x, long &y)
  315. {
  316.   mouse_to_game(screenx,screeny,x,y);
  317.   x/=ftile_width();
  318.   y/=ftile_height();
  319.   /*  view *f=view_in(screenx,screeny);
  320.       if (f)
  321.       {
  322.       x=((long)(screenx)-(long)f->cx1+f->xoff())/(long)f_wid;
  323.       y=((long)(screeny)-(long)f->cy1+f->yoff())/(long)f_hi;
  324.       }
  325.       else
  326.       {
  327.       x=-1; 
  328.       y=-1;
  329.       }*/
  330. }
  331.  
  332. void game::btile_on(int screenx, int screeny, long &x, long &y)
  333. {
  334.   view *f=view_in(screenx,screeny);
  335.   if (f)
  336.   {
  337.     x=((long)(screenx)-(long)f->cx1+f->xoff()*bg_xmul/bg_xdiv)/(long)b_wid; 
  338.     y=((long)(screeny)-(long)f->cy1+f->yoff()*bg_ymul/bg_ydiv)/(long)b_hi;
  339.   }
  340.   else
  341.   {
  342.     x=-1; 
  343.     y=-1;
  344.   }
  345. }
  346.  
  347.  
  348. void game::mouse_to_game(long x, long y, long &gamex, long &gamey, view *f)
  349. {
  350.   if (!f)
  351.   {
  352.     f=view_in(x,y);
  353.     if (!f) f=player_list;  // if not in a view use the first on
  354.   }
  355.  
  356.   if (f)
  357.   {
  358.     if (dev&MAP_MODE)
  359.     {
  360.       gamex=((x-(long)f->cx1)*ftile_width()/AUTOTILE_WIDTH+map_xoff*ftile_width());
  361.       gamey=((y-(long)f->cy1)*ftile_height()/AUTOTILE_HEIGHT+map_yoff*ftile_height());
  362.     } else
  363.     {
  364.       gamex=(x-(long)f->cx1+f->xoff());
  365.       gamey=(y-(long)f->cy1+f->yoff());
  366.     }
  367.   }
  368. }
  369.  
  370. void game::game_to_mouse(long gamex, long gamey, view *which, long &x, long &y)
  371. {
  372.   if (dev&MAP_MODE)
  373.   {
  374.     long x1,y1;
  375.     if (dev&EDIT_MODE)
  376.     {
  377.       x1=map_xoff;
  378.       y1=map_yoff;
  379.     } else
  380.     {
  381.       if (which->focus)
  382.       {
  383.     x1=which->focus->x/ftile_width()-(which->cx2-which->cx1)/AUTOTILE_WIDTH/2;
  384.     y1=which->focus->y/ftile_height()-(which->cy2-which->cy1)/AUTOTILE_HEIGHT/2;
  385.       } else x1=y1=0;
  386.     }
  387.     if (x1<0) x1=0;
  388.     if (y1<0) y1=0;
  389.  
  390.     x=gamex*AUTOTILE_WIDTH/ftile_width()-x1*AUTOTILE_WIDTH+which->cx1;
  391.     if (x1>0)
  392.       x-=((which->focus->x*AUTOTILE_WIDTH/ftile_width()) %AUTOTILE_WIDTH);
  393.  
  394.     y=gamey*AUTOTILE_HEIGHT/ftile_height()-y1*AUTOTILE_HEIGHT+which->cy1;
  395.     if (y1>0)
  396.       y-=((which->focus->y*AUTOTILE_HEIGHT/ftile_height()) %AUTOTILE_HEIGHT);
  397.   }
  398.   else
  399.   {
  400.     x=gamex-which->xoff()+which->cx1;
  401.     y=gamey-which->yoff()+which->cy1;
  402.   }
  403. }
  404.  
  405. int window_state(int state)
  406. {
  407.   switch (state)
  408.   {
  409.     case RUN_STATE : 
  410.     case PAUSE_STATE : 
  411.     case JOY_CALB_STATE :
  412.     { return 1; } break;
  413.  
  414.     case INTRO_START_STATE :
  415.     case HELP_STATE : 
  416.     case INTRO_MORPH_STATE :
  417.     case MENU_STATE :
  418.     case SCENE_STATE :
  419.     { return 0; } break;
  420.   }
  421.   return 1;
  422. }
  423.  
  424.  
  425. // not global for now
  426. extern void make_edit_mode_menu();
  427. extern void kill_edit_mode_menu();
  428.  
  429. void game::set_state(int new_state) 
  430. {
  431.   int d=0;
  432.   
  433.   reset_keymap();                             // we think all the keys are up right now
  434.  
  435.   if (!playing_state(new_state) && playing_state(state))
  436.   {
  437.     switch_mode(VMODE_640x480);
  438.   }
  439.  
  440.   if (playing_state(new_state) && !playing_state(state))
  441.   {
  442.     switch_mode(VMODE_320x200);
  443.     recalc_local_view_space();
  444.  
  445.     if (first_view && first_view!=player_list)
  446.     {
  447.       while (first_view)
  448.       {
  449.         view *tmp=first_view;
  450.         first_view=first_view->next;
  451.         delete tmp;
  452.       }
  453.       first_view=old_view;
  454.       old_view=NULL;
  455.     }
  456.     first_view=player_list;
  457.     d=1;
  458.   } else if (!playing_state(new_state) && (playing_state(state) || state==START_STATE))
  459.   {
  460.     if (player_list)    
  461.     {
  462.       first_view=new view(player_list->focus,NULL,-1);
  463.       first_view->pan_x=player_list->xoff();
  464.       first_view->pan_y=player_list->yoff();
  465.     }
  466.     else    
  467.       first_view=new view(NULL,NULL,0);
  468.  
  469.     /*
  470.     first_view->cx1=(xres+1)/2-155;
  471.     first_view->cy1=(yres+1)/2-95;
  472.     first_view->cx2=(xres+1)/2+155;
  473.     if (total_weapons)
  474.       first_view->cy2=(yres+1)/2+68;
  475.     else
  476.       first_view->cy2=(yres+1)/2+95;
  477.       */
  478.     
  479.     d=1;
  480.   }
  481.   
  482.  
  483.  
  484.   // switching to/from scene mode cause the screen size to change and the border to change
  485.   // so we need to redraw.
  486.   if (window_state(new_state) && !window_state(state))
  487.     eh->show_windows();
  488.   else if (!window_state(new_state) && window_state(state))
  489.     eh->hide_windows();
  490.  
  491.   int old_state=state;
  492.   state=new_state;
  493.  
  494.   pal->load();    // restore old palette
  495.  
  496.   if (playing_state(state) &&  !(dev&EDIT_MODE))
  497.     eh->set_mouse_shape(cash.img(c_target)->copy(),8,8);
  498.   else
  499.     eh->set_mouse_shape(cash.img(c_normal)->copy(),1,1);
  500.  
  501.     if (playing_state(new_state) && (dev&EDIT_MODE))
  502.         make_edit_mode_menu();
  503.     else
  504.         kill_edit_mode_menu();
  505.     
  506.   if (old_state==SCENE_STATE && new_state!=SCENE_STATE)
  507.   {
  508.     d=1;
  509.     scene_director.set_abort(0);   // don't skip any more scene stuff
  510.   }
  511.   else if (new_state==SCENE_STATE && old_state!=SCENE_STATE)
  512.     d=1;
  513.   
  514.   if (d)
  515.     draw(state==SCENE_STATE);
  516.  
  517.   dev_cont->set_state(new_state);
  518. }
  519.  
  520. void game::joy_calb(event &ev)
  521. {
  522.   if (joy_win)   // make sure the joy stick calibration window is open
  523.   {
  524.     
  525.     if (ev.type==EV_SPURIOUS)   // spurious means we should update your status
  526.     {
  527.       int b1,b2,b3=0,x,y;
  528.       joy_status(b1,b2,b2,x,y);
  529.       int but=b1|b2|b3;
  530.       if (x>0) x=1; else if (x<0) x=-1;
  531.       if (y>0) y=1; else if (y<0) y=-1;
  532.       if (but) but=1;
  533.       int dx=WINDOW_FRAME_LEFT+20,dy=WINDOW_FRAME_TOP+5;
  534.       image *jim=cash.img(joy_picts[but*9+(y+1)*3+x+1]);
  535.       joy_win->screen->bar(dx,dy,dx+jim->width()+6,dy+jim->height()+6,eh->black());
  536.       jim->put_image(joy_win->screen,dx+3,dy+3);
  537.  
  538.       if (but)
  539.         joy_calibrate();
  540.     } else if (ev.type==EV_MESSAGE && ev.message.id==JOY_OK)
  541.     {
  542.       eh->close_window(joy_win);
  543.       joy_win=NULL;
  544.       set_state(MENU_STATE);
  545.     }        
  546.   }
  547. }
  548.  
  549. void game::menu_select(event &ev)
  550. {
  551.   state=DEV_MOUSE_RELEASE;
  552.   if (top_menu)
  553.   {
  554.     /*    eh->push_event(new event(men_mess[((pick_list *)ev.message.data)->get_selection()],NULL));
  555.           eh->close_window(top_menu);
  556.           top_menu=NULL;*/
  557.   }
  558. }
  559.  
  560.  
  561. void game::show_help(char *st)
  562. {
  563.   strcpy(help_text,st);
  564.   help_text_frames=0;  
  565.   refresh=1;
  566. }
  567.  
  568. void game::draw_value(image *screen, int x, int y, int w, int h, int val, int max)
  569. {
  570.   screen->bar(x,y,x+w-1,y+h,eh->dark_color());
  571.   screen->bar(x,y+1,x+w*val/max,y+h-1,eh->bright_color());  
  572. }
  573.  
  574.  
  575. void game::set_level(level *nl)
  576. {
  577.   if (current_level) 
  578.     delete current_level;  
  579.   current_level=nl;
  580. }
  581.  
  582. void game::load_level(char *name)
  583. {
  584.   if (current_level) 
  585.     delete current_level;
  586.  
  587.   bFILE *fp=open_file(name,"rb");
  588.  
  589.   if (fp->open_failure())
  590.   {
  591.     delete fp;
  592.     current_level=new level(100,100,name);
  593.     char msg[100];
  594.     sprintf(msg,symbol_str("no_file"),name);
  595.     show_help(msg);
  596.   }
  597.   else
  598.   {                  
  599.     spec_directory sd(fp);  
  600.  
  601. #ifdef __MAC__
  602.  
  603.     if (state != RUN_STATE)
  604.     {
  605.       // clear screen
  606.       image blank(2,2); blank.clear();
  607.       fade_out(16);
  608.       eh->set_mouse_shape(blank.copy(),0,0);      // don't show mouse
  609.       fade_in(cash.img(cdc_logo),16);
  610.     }
  611. #endif
  612.  
  613.     spec_entry *e=sd.find("Copyright 1995 Crack dot Com, All Rights reserved"); 
  614.     if (!e)
  615.     { 
  616.       the_game->show_help(symbol_str("missing_c"));
  617.       current_level=new level(100,100,"untitled");
  618.       the_game->need_refresh();
  619.     }
  620.     else 
  621.       current_level=new level(&sd,fp,name);
  622.     delete fp;
  623.   }
  624.   
  625.   base->current_tick=(current_level->tick_counter()&0xff); 
  626.  
  627.   current_level->level_loaded_notify();
  628.   the_game->help_text_frames=0;  
  629.  
  630. }
  631.  
  632. int game::done() 
  633. { 
  634.   return finished || (main_net_cfg && main_net_cfg->restart_state());
  635.  
  636. }
  637.  
  638. void game::end_session()
  639. {
  640.   finished=1;
  641.   if (main_net_cfg)
  642.   {
  643.     delete main_net_cfg;
  644.     main_net_cfg=NULL;
  645.   }
  646. }
  647.  
  648. void game::put_block_fg(int x, int y, trans_image *im)
  649. {
  650.   for (view *f=first_view;f;f=f->next)
  651.   {
  652.     if (f->drawable())
  653.     {
  654.       int xoff=f->xoff(),yoff=f->yoff(),viewx1=f->cx1,viewy1=f->cy1,viewx2=f->cx2,viewy2=f->cy2;
  655.       if (xoff/ftile_width()>x || xoff/ftile_width()+(viewx2-viewx1)/ftile_width()+1<x ||
  656.       yoff/ftile_height()>y || yoff/ftile_height()+(viewy2-viewy1)/ftile_height()+1<y) return;
  657.       short cx1,cy1,cx2,cy2;
  658.       screen->get_clip(cx1,cy1,cx2,cy2);
  659.       screen->set_clip(viewx1,viewy1,viewx2,viewy2);
  660.       im->put_image(screen,(x-xoff/ftile_width())*ftile_width()+viewx1-xoff%ftile_width(),
  661.           (y-yoff/ftile_height())*ftile_height()+viewy1-yoff%ftile_height());
  662.       screen->set_clip(cx1,cy1,cx2,cy2);
  663.     }
  664.   }
  665. }
  666.  
  667. void game::put_block_bg(int x, int y, image *im)
  668. {
  669.   for (view *f=first_view;f;f=f->next)
  670.   {
  671.     if (f->drawable())
  672.     {
  673.       int xoff=f->xoff(),yoff=f->yoff(),viewx1=f->cx1,viewy1=f->cy1,viewx2=f->cx2,viewy2=f->cy2;
  674.       int xo=xoff*bg_xmul/bg_xdiv;
  675.       int yo=yoff*bg_ymul/bg_ydiv;
  676.       
  677.       if (xo/btile_width()>x || xo/btile_width()+(viewx2-viewx1)/btile_width()+1<x ||
  678.       yo/btile_height()>y || yo/btile_height()+(viewy2-viewy1)/btile_height()+1<y) return;
  679.       short cx1,cy1,cx2,cy2;
  680.       screen->get_clip(cx1,cy1,cx2,cy2);
  681.       screen->set_clip(viewx1,viewy1,viewx2,viewy2);
  682.       im->put_image(screen,(x-xo/btile_width())*btile_width()+viewx1-xo%btile_width(),
  683.           (y-yo/btile_height())*btile_height()+viewy1-yo%btile_height(),0);
  684.       screen->set_clip(cx1,cy1,cx2,cy2);
  685.     }
  686.   }
  687. }
  688.  
  689. int need_delay=1;
  690.  
  691. void game::dev_scroll()
  692. {
  693.   need_delay=0;
  694.   if (dev)
  695.   {
  696.     int xmargin,ymargin;
  697.     if (xres>400)
  698.     {
  699.       xmargin=20;
  700.       ymargin=10;
  701.     }
  702.     else 
  703.     {
  704.       xmargin=10;
  705.       ymargin=5;
  706.     }
  707.  
  708.     int xs,ys;
  709.     if (mousex<xmargin &&  dev_cont->ok_to_scroll()) xs=-18;
  710.     else if (mousex>(screen->width()-xmargin) &&  dev_cont->ok_to_scroll()) xs=18;
  711.     else if (eh->key_pressed(JK_LEFT) && !last_input && !dev_cont->need_arrows())
  712.       xs=-18;
  713.     else if (eh->key_pressed(JK_RIGHT) && !last_input && !dev_cont->need_arrows())
  714.       xs=18;
  715.     else xs=0;
  716.          
  717.  
  718.     if (mousey<ymargin && dev_cont->ok_to_scroll()) ys=-18;
  719.     else if (mousey>(screen->height()-ymargin) &&  dev_cont->ok_to_scroll()) ys=18;
  720.     else if (eh->key_pressed(JK_UP) && !last_input)
  721.       ys=-18;
  722.     else if (eh->key_pressed(JK_DOWN) && !last_input)
  723.       ys=18;
  724.     else ys=0;
  725.  
  726.     
  727.     if (xs || ys)
  728.     {
  729.       need_delay=1;
  730.       if (dev&MAP_MODE)
  731.       {
  732.         map_xoff+=xs/2;
  733.         map_yoff+=ys/2;
  734.         if (map_xoff<0) map_xoff=0;
  735.         if (map_yoff<0) map_yoff=0;
  736.       } 
  737.       else
  738.       { 
  739.         for (view *v=first_view;v;v=v->next)
  740.         {
  741.           if (xs>=0 || v->xoff()>0)
  742.             v->pan_x+=xs;
  743.           if (ys>=0 || v->yoff()>0)
  744.             v->pan_y+=ys;
  745.         }
  746.       }
  747.       refresh=1;
  748.     }
  749.   }
  750. }
  751.  
  752. void remap_area(image *screen, int x1, int y1, int x2, int y2, uchar *remap)
  753. {
  754.   uchar *sl=(uchar *)screen->scan_line(y1)+x1;
  755.   int x,y,a=screen->width()-(x2-x1+1);
  756.   uchar c;
  757.   for (y=y1;y<=y2;y++)
  758.   {
  759.     for (x=x1;x<=x2;x++)
  760.     {
  761.       c=*sl;
  762.       *(sl++)=remap[c];
  763.     }
  764.     sl+=a;
  765.   }
  766. }
  767.  
  768. void post_render()
  769. {
  770.   if (DEFINEDP(symbol_function(l_post_render)))
  771.   {
  772.     screen->dirt_off();
  773.     clear_tmp();
  774.     eval_function((lisp_symbol *)l_post_render,NULL);
  775.     clear_tmp();
  776.     screen->dirt_on();
  777.   }
  778. }
  779.   
  780. void game::draw_map(view *v, int interpolate)
  781. {
  782.   foretile *ft;
  783.   backtile *bt;
  784.   int x1,y1,x2,y2,x,y,xo,yo,nxoff,nyoff;
  785.   short cx1,cy1,cx2,cy2;
  786.   
  787.   StartTime(6); //kill me
  788.   
  789.   screen->get_clip(cx1,cy1,cx2,cy2);
  790.  
  791.   if (!current_level || state==MENU_STATE)
  792.   {
  793.     if (title_screen>=0)
  794.     {
  795.       if (state==SCENE_STATE)
  796.         screen->set_clip(v->cx1,v->cy1,v->cx2,v->cy2);        
  797.       image *tit=cash.img(title_screen);
  798.       tit->put_image(screen,screen->width()/2-tit->width()/2,
  799.           screen->height()/2-tit->height()/2);
  800.       if (state==SCENE_STATE)
  801.         screen->set_clip(cx1,cy1,cx2,cy2);
  802.       eh->flush_screen();
  803.     }   
  804.     return ;
  805.   }
  806.  
  807.   refresh=0;  
  808.  
  809.  
  810.   // save the dirty rect routines some work by markinging evrything in the 
  811.   // view area dirty alreadt
  812.  
  813.   if (small_render)
  814.     screen->add_dirty(v->cx1,v->cy1,(v->cx2-v->cx1+1)*2+v->cx1,v->cy1+(v->cy2-v->cy1+1)*2);    
  815.   else
  816.     screen->add_dirty(v->cx1,v->cy1,v->cx2,v->cy2);    
  817.  
  818.   if (v->draw_solid!=-1)      // fill the screen and exit..
  819.   {
  820.     int c=v->draw_solid;
  821.     for (int y=v->cy1;y<=v->cy2;y++)
  822.       memset(screen->scan_line(y)+v->cx1,c,v->cx2-v->cx1+1);
  823.     v->draw_solid=-1;
  824.     return ;
  825.   }
  826.  
  827.   long old_cx1,old_cy1,old_cx2,old_cy2;   // if we do a small render, we need to restore these
  828.   image *old_screen=NULL;
  829.   if (small_render && (dev&DRAW_LIGHTS))  // cannot do this if we skip lighting
  830.   {
  831.     old_cx1=v->cx1;
  832.     old_cy1=v->cy1;
  833.     old_cx2=v->cx2;
  834.     old_cy2=v->cy2;
  835.  
  836.     /*    v->cx1=0;
  837.     v->cy1=0;
  838.     v->cx2=small_render->width()-1;
  839.     v->cy2=small_render->height()-1; */
  840.  
  841.     old_screen=screen;
  842.     screen=small_render;
  843.   } else
  844.     screen->dirt_off();
  845.  
  846.  
  847.  
  848.   //  long max_xoff=(current_level->foreground_width()-1)*ftile_width()-(v->cx2-v->cx1+1);
  849.   //  long max_yoff=(current_level->foreground_height()-1)*ftile_height()-(v->cy2-v->cy1+1); 
  850.  
  851.   long xoff,yoff;
  852.   if (interpolate)
  853.   {
  854.     xoff=v->interpolated_xoff();
  855.     yoff=v->interpolated_yoff();
  856.   } else
  857.   {
  858.     xoff=v->xoff();
  859.     yoff=v->yoff();
  860.   }
  861.  
  862.   //  if (xoff>max_xoff) xoff=max_xoff;
  863.   //  if (yoff>max_yoff) yoff=max_yoff;  
  864.  
  865.   current_vxadd=xoff-v->cx1;
  866.   current_vyadd=yoff-v->cy1;
  867.  
  868.   screen->set_clip(v->cx1,v->cy1,v->cx2,v->cy2);
  869.  
  870.   nxoff=xoff*bg_xmul/bg_xdiv;
  871.   nyoff=yoff*bg_ymul/bg_ydiv;
  872.  
  873.   //  long max_bg_xoff=(current_level->background_width())*btile_width()-(v->cx2-v->cx1+1);
  874.   //  long max_bg_yoff=(current_level->background_height())*btile_height()-(v->cy2-v->cy1+1);
  875.   //  if (nxoff>max_bg_xoff) nxoff=max_xoff;
  876.   //  if (nyoff>max_bg_yoff) nyoff=max_yoff;  
  877.   
  878.   
  879.   x1=nxoff/btile_width(); y1=nyoff/btile_height();
  880.   x2=x1+(v->cx2-v->cx1+btile_width())/btile_width();
  881.   y2=y1+(v->cy2-v->cy1+btile_height())/btile_height();
  882.  
  883.  
  884.   xo=v->cx1-nxoff%btile_width();
  885.   yo=v->cy1-nyoff%btile_height();
  886.   
  887.   int xinc,yinc,draw_x,draw_y;
  888.  
  889.  
  890.   DiffTime("      PreDraw",6);//kill me
  891.   StartTime(7); //kill me
  892.   if (!(dev & MAP_MODE) && (dev & DRAW_BG_LAYER))
  893.   {
  894.     xinc=btile_width();  
  895.     yinc=btile_height();  
  896.     
  897.     int bh=current_level->background_height(),bw=current_level->background_width();
  898.     ushort *bl;
  899.     for (draw_y=yo,y=y1;y<=y2;y++,draw_y+=yinc)
  900.     {
  901.       if (y>=bh)
  902.         bl=NULL;
  903.       else
  904.         bl=current_level->get_bgline(y)+x1;
  905.  
  906.       for (x=x1,draw_x=xo;x<=x2;x++,draw_x+=xinc)
  907.       {
  908.         if (x<bw && y<bh)
  909.         {
  910.           bt=get_bg(*bl);
  911.           bl++;
  912.         }
  913.         else bt=get_bg(0);
  914.  
  915.         bt->im->put_image(screen,draw_x,draw_y); 
  916.         //        if (!(dev & EDIT_MODE) && bt->next)
  917.         //      current_level->put_bg(x,y,bt->next);
  918.       }
  919.     }
  920.   }
  921.   //  if (!(dev&EDIT_MODE))
  922.   //    server_check();
  923.  
  924.   uchar rescan=0;  
  925.  
  926.   int fw,fh;
  927.  
  928.   if (dev&MAP_MODE)
  929.   {
  930.     fw=AUTOTILE_WIDTH;
  931.     fh=AUTOTILE_HEIGHT;
  932.     if (dev&EDIT_MODE)
  933.     {
  934.       x1=map_xoff;
  935.       y1=map_yoff;
  936.     } else
  937.     {
  938.       if (v->focus)
  939.       {
  940.         x1=v->focus->x/ftile_width()-(v->cx2-v->cx1)/fw/2;
  941.         y1=v->focus->y/ftile_height()-(v->cy2-v->cy1)/fh/2;
  942.       } else x1=y1=0;
  943.     }
  944.     if (x1>0)
  945.       xo=v->cx1-((v->focus->x*fw/ftile_width()) %fw);
  946.     else xo=v->cx1;
  947.     if (y1>0)
  948.       yo=v->cy1-((v->focus->y*fh/ftile_height()) %fh);
  949.     else yo=v->cy1;
  950.   } else
  951.   {
  952.     fw=ftile_width();
  953.     fh=ftile_height();
  954.     x1=(xoff)/fw; y1=(yoff)/fh;
  955.     xo=v->cx1-xoff%fw;
  956.     yo=v->cy1-yoff%fh;
  957.  
  958.   }
  959.   if (x1<0) x1=0;
  960.   if (y1<0) y1=0;
  961.   
  962.   x2=x1+(v->cx2-v->cx1+fw)/fw;
  963.   y2=y1+(v->cy2-v->cy1+fh)/fh;
  964.   if (x2>=current_level->foreground_width())
  965.     x2=current_level->foreground_width()-1;
  966.   if (y2>=current_level->foreground_height())
  967.     y2=current_level->foreground_height()-1;
  968.  
  969.  
  970.   xinc=fw;
  971.   yinc=fh;
  972.  
  973.   DiffTime("      BG/MAP",7);//kill me
  974.   StartTime(8); //kill me
  975.  
  976.   if (dev & DRAW_FG_LAYER)
  977.   {
  978.     short ncx1,ncy1,ncx2,ncy2;
  979.     screen->get_clip(ncx1,ncy1,ncx2,ncy2);
  980.  
  981.     int scr_w=screen->width();
  982.     if (dev&MAP_MODE)
  983.     {
  984.       if (dev&EDIT_MODE)
  985.         screen->clear(eh->bright_color());
  986.       else
  987.         screen->clear(eh->black());
  988.       for (y=y1,draw_y=yo;y<=y2;y++,draw_y+=yinc)
  989.       {
  990.         if (!(draw_y<ncy1 ||draw_y+yinc>=ncy2))
  991.         {
  992.           ushort *cl=current_level->get_fgline(y)+x1;
  993.           uchar *sl1=screen->scan_line(draw_y)+xo;
  994.           for (x=x1,draw_x=xo;x<=x2;x++,cl++,sl1+=xinc,draw_x+=xinc)
  995.           {
  996.             if (!(draw_x<ncx1 || draw_x+xinc>=ncx2))
  997.             {
  998.               int fort_num;
  999.               //          if (*cl&0x8000 || (dev&EDIT_MODE))
  1000.               fort_num=fgvalue(*cl);
  1001.               //          else fort_num=0;
  1002.             
  1003.               uchar *sl2=get_fg(fort_num)->micro_image->scan_line(0);
  1004.               uchar *sl3=sl1;
  1005.               memcpy(sl3,sl2,AUTOTILE_WIDTH); sl2+=AUTOTILE_WIDTH; sl3+=scr_w;
  1006.               memcpy(sl3,sl2,AUTOTILE_WIDTH); sl2+=AUTOTILE_WIDTH; sl3+=scr_w;
  1007.               memcpy(sl3,sl2,AUTOTILE_WIDTH);
  1008.             }
  1009.           }
  1010.         }
  1011.       }
  1012.  
  1013.       if (dev&EDIT_MODE)
  1014.         current_level->draw_areas(v);
  1015.     } else
  1016.     {
  1017.  
  1018.       int fg_h=current_level->foreground_height(),fg_w=current_level->foreground_width();
  1019.       
  1020.       for (y=y1,draw_y=yo;y<=y2;y++,draw_y+=yinc)
  1021.       {
  1022.     
  1023.         ushort *cl;
  1024.         if (y<fg_h)
  1025.           cl=current_level->get_fgline(y)+x1;
  1026.         else cl=NULL;
  1027.         uchar *sl1=draw_y<ncy1 ? 0 : screen->scan_line(draw_y)+xo;
  1028.             
  1029.         for (x=x1,draw_x=xo;x<=x2;x++,draw_x+=xinc,cl++,sl1+=xinc)
  1030.         {
  1031.           if (x<fg_w && y<fg_h)
  1032.           {
  1033.             if (above_tile(*cl))
  1034.               rescan=1;
  1035.             else
  1036.             {
  1037.               int fort_num=fgvalue(*cl);      
  1038.               if (fort_num!=BLACK)
  1039.               {
  1040.                 if (draw_y<ncy1 || draw_y+yinc>=ncy2 || draw_x<ncx1 || draw_x+xinc>=ncx2)
  1041.                   get_fg(fort_num)->im->put_image(screen,draw_x,draw_y);
  1042.                 else
  1043.                   get_fg(fort_num)->im->put_image_offseted(screen,sl1);
  1044.             
  1045.                 if (!(dev & EDIT_MODE))
  1046.                   *cl|=0x8000;      // mark as has-been-seen
  1047.               }    
  1048.             }
  1049.           }
  1050.         }
  1051.       }  
  1052.     }
  1053.     /*        if (dev==0)
  1054.               current_level->put_fg(x,y,ft->next);  */       
  1055.   }
  1056.   
  1057.   DiffTime("      FG",8);//kill me
  1058.  
  1059.   //  if (!(dev&EDIT_MODE))
  1060.   //    server_check();
  1061.  
  1062.   long ro=rand_on;
  1063.   if (dev & DRAW_PEOPLE_LAYER)
  1064.   {
  1065.     if (interpolate)
  1066.       current_level->interpolate_draw_objects(v);
  1067.     else
  1068.       current_level->draw_objects(v);
  1069.   }
  1070.  
  1071.   //  if (!(dev&EDIT_MODE))
  1072.   //    server_check();
  1073.  
  1074.   StartTime(9); //kill me
  1075.   if (!(dev&MAP_MODE))
  1076.   {
  1077.  
  1078.     int fg_h=current_level->foreground_height(),fg_w=current_level->foreground_width();
  1079.  
  1080.     if (dev & DRAW_FG_LAYER && rescan)
  1081.     {
  1082.       for (y=y1,draw_y=yo;y<=y2;y++,draw_y+=yinc)
  1083.       {
  1084.         ushort *cl=current_level->get_fgline(y)+x1;
  1085.         for (x=x1,draw_x=xo;x<=x2;x++,draw_x+=xinc,cl++)
  1086.         {
  1087.           if (above_tile(*cl))
  1088.           {
  1089.             int fort_num=fgvalue(*cl);      
  1090.             if (fort_num!=BLACK)
  1091.             {
  1092.               if (dev & DRAW_BG_LAYER)
  1093.                 get_fg(fort_num)->im->put_image(screen,draw_x,draw_y);
  1094.               else
  1095.                 get_fg(fort_num)->im->put_image_filled(screen,draw_x,draw_y,0);
  1096.             
  1097.               if (!(dev & EDIT_MODE))
  1098.                 current_level->mark_seen(x,y);
  1099.               else
  1100.               {
  1101.                 screen->line(draw_x,draw_y,draw_x+xinc,draw_y+yinc,eh->bright_color());
  1102.                 screen->line(draw_x+xinc,draw_y,draw_x,draw_y+yinc,eh->bright_color());
  1103.               }
  1104.             }    
  1105.           }
  1106.         }
  1107.       }   
  1108.     }
  1109.  
  1110.     
  1111.     if (dev & DRAW_FG_BOUND_LAYER)
  1112.     {
  1113.       int b=eh->bright_color();
  1114.       int fg_h=current_level->foreground_height(),fg_w=current_level->foreground_width();
  1115.  
  1116.       for (y=y1,draw_y=yo;y<=y2;y++,draw_y+=yinc)
  1117.       {
  1118.         ushort *cl;
  1119.         if (y<fg_h)
  1120.           cl=current_level->get_fgline(y)+x1;
  1121.         else cl=NULL;
  1122.         for (x=x1,draw_x=xo;x<=x2;x++,draw_x+=xinc,cl++)
  1123.         {
  1124.           if (x<fg_w && y<fg_h)
  1125.           {
  1126.             int fort_num=fgvalue(*cl);      
  1127.             if (fort_num!=BLACK)
  1128.             {
  1129.               point_list *p=get_fg(fort_num)->points;
  1130.               uchar *d=p->data;    
  1131.               if (p->tot)
  1132.               {
  1133.                 for (int i=1;i<p->tot;i++)
  1134.                 {
  1135.                   d+=2;
  1136.                   screen->line(draw_x+*(d-2),draw_y+*(d-1),draw_x+*d,draw_y+*(d+1),b);
  1137.                 }
  1138.                 screen->line(draw_x+*d,draw_y+*(d-1),draw_x+p->data[0],draw_y+p->data[1],b);
  1139.               }
  1140.             }
  1141.           }
  1142.         }
  1143.       }
  1144.     }
  1145.  
  1146.     //    if (!(dev&EDIT_MODE))
  1147.     //      server_check();
  1148.  
  1149.     if (dev & DRAW_HELP_LAYER)
  1150.     {
  1151.       if (help_text_frames>=0)
  1152.       {
  1153.         int color;
  1154.                 
  1155.         if (help_text_frames<10)
  1156.           color=2;
  1157.         else
  1158.           color=2+(help_text_frames-10);
  1159.                 
  1160.         int x1=v->cx1,y1=v->cy1,x2=v->cx2,y2=v->cy1+eh->font()->height()+10;
  1161.             
  1162.         remap_area(screen,x1,y1,x2,y2,white_light+40*256);
  1163.         screen->bar(x1,y1,x2,y1,color);
  1164.         screen->bar(x1,y2,x2,y2,color);
  1165.             
  1166.         eh->frame_font()->put_string(screen,x1+5,y1+5,
  1167.             help_text,color);
  1168.         if (color>30)
  1169.           help_text_frames=-1;      
  1170.         else help_text_frames++;
  1171.     
  1172.       }    
  1173.     }
  1174.     
  1175.     if (dev_cont)
  1176.       dev_cont->dev_draw(v);  
  1177.     if (cash.in_use())
  1178.       cash.img(vmm_image)->put_image(screen,v->cx1,v->cy2-cash.img(vmm_image)->height()+1);  
  1179.  
  1180.     if (dev&DRAW_LIGHTS)
  1181.     {  
  1182.       if (small_render)
  1183.       {
  1184.         double_light_screen(screen,xoff,yoff,white_light,v->ambient,old_screen,old_cx1,old_cy1);
  1185.             
  1186.         /*        v->cx1=old_cx1;
  1187.         v->cy1=old_cy1;
  1188.         v->cx2=old_cx2;
  1189.         v->cy2=old_cy2; */
  1190.         screen=old_screen;
  1191.       } else
  1192.       {      
  1193.         screen->dirt_on();
  1194.         if (xres*yres<=64000)
  1195.           light_screen(screen,xoff,yoff,white_light,v->ambient);
  1196.         else light_screen(screen,xoff,yoff,white_light,63);            // no lighting for hi-rez
  1197.       }
  1198.  
  1199.     } else 
  1200.       screen->dirt_on();
  1201.  
  1202.  
  1203.  
  1204.   }  else
  1205.     screen->dirt_on();
  1206.  
  1207.   DiffTime("      Other",9); //kill me
  1208.  
  1209.   StartTime(15); // kill me
  1210.   rand_on=ro;                // restore random start in case in draw funs moved it
  1211.   // ... not every machine will draw the same thing
  1212.  
  1213.   post_render();
  1214.  
  1215.   screen->set_clip(cx1,cy1,cx2,cy2);
  1216.     
  1217.  
  1218.  
  1219.  
  1220.   if (playing_state(state))        // draw stuff outside the clipping region
  1221.     v->draw_character_damage();
  1222.  
  1223.   if (profiling())
  1224.     profile_update();
  1225.  
  1226.   sbar.draw_update();
  1227.   DiffTime("      Post",15); //kill me
  1228. }
  1229.  
  1230. void game::put_fg(int x, int y, int type)
  1231. { 
  1232.   if (current_level->get_fg(x,y)!=type)
  1233.   {
  1234.     current_level->put_fg(x,y,type);
  1235.     for (view *f=first_view;f;f=f->next)
  1236.       if (f->drawable())
  1237.         draw_map(f);    
  1238.     /*    put_block_bg(x,y,get_bg(current_level->get_bg(x/ASPECT,y/ASPECT))->im);
  1239.           if (type>BLACK)
  1240.           put_block_fg(x,y,get_fg(type)->im); */
  1241.   }
  1242. }
  1243.  
  1244. void game::put_bg(int x, int y, int type)
  1245. {
  1246.   if (current_level->get_bg(x,y)!=type)
  1247.   {
  1248.     current_level->put_bg(x,y,type);
  1249.     for (view *f=first_view;f;f=f->next)
  1250.       if (f->drawable())
  1251.         draw_map(f);    
  1252.     /*    put_block_bg(x,y,get_bg(type)->im);
  1253.           if (current_level->get_fg(x,y)>BLACK) 
  1254.           put_block_fg(x,y,get_fg(current_level->get_fg(x,y))->im);*/
  1255.   }
  1256. }
  1257.  
  1258. int game::in_area(event &ev, int x1, int y1, int x2, int y2)
  1259. {
  1260.   return (last_demo_mx>=x1 && last_demo_mx<=x2 &&
  1261.       last_demo_my>=y1 && last_demo_my<=y2);
  1262. }
  1263.  
  1264. void game::request_level_load(char *name)
  1265. {
  1266.   strcpy(req_name,name);
  1267. }
  1268.  
  1269. extern int start_doubled;
  1270.  
  1271. void fade_in(image *im, int steps)
  1272. {
  1273.   palette *old_pal=pal->copy();
  1274.   int i;
  1275.   if (im)
  1276.   {
  1277.     screen->clear();
  1278.     im->put_image(screen,(xres+1)/2-im->width()/2,(yres+1)/2-im->height()/2);
  1279.   }
  1280.  
  1281.   for (i=0;i<steps;i++)
  1282.   {
  1283.     uchar *sl1=(uchar *)pal->addr();    
  1284.     uchar *sl2=(uchar *)old_pal->addr();    
  1285.     int j;
  1286.     int r,g,b;
  1287.     int v=(i+1)*256/steps;
  1288.     for (j=0;j<256;j++)
  1289.     {
  1290.       *(sl1)=((int)*(sl2))*v/256;  sl1++; sl2++;
  1291.       *(sl1)=((int)*(sl2))*v/256;  sl1++; sl2++;
  1292.       *(sl1)=((int)*(sl2))*v/256;  sl1++; sl2++;
  1293.     }
  1294.     pal->load();
  1295.     eh->flush_screen();
  1296.     milli_wait(25);
  1297.   }
  1298.   delete pal;
  1299.   pal=old_pal;
  1300. }
  1301.  
  1302. void fade_out(int steps)
  1303. {
  1304.   palette *old_pal=pal->copy();
  1305.   int i;
  1306.   for (i=0;i<steps;i++)
  1307.   {
  1308.     uchar *sl1=(uchar *)pal->addr();    
  1309.     uchar *sl2=(uchar *)old_pal->addr();    
  1310.     int j;
  1311.     int r,g,b;
  1312.     int v=(steps-i)*256/steps;
  1313.     for (j=0;j<256;j++)
  1314.     {
  1315.       *(sl1)=((int)*(sl2))*v/256;  sl1++; sl2++;
  1316.       *(sl1)=((int)*(sl2))*v/256;  sl1++; sl2++;
  1317.       *(sl1)=((int)*(sl2))*v/256;  sl1++; sl2++;
  1318.     }
  1319.     pal->load();
  1320.     eh->flush_screen();
  1321.     milli_wait(25);
  1322.   }
  1323.   screen->clear();
  1324.   eh->flush_screen();
  1325.   delete pal;
  1326.   pal=old_pal;
  1327.   
  1328.   pal->load();
  1329. }
  1330.  
  1331. int text_draw(int y, int x1, int y1, int x2, int y2, char *buf, JCFont *font, uchar *cmap, char color);
  1332.  
  1333. void do_title()
  1334. {
  1335.   if (cdc_logo!=-1)
  1336.   {
  1337.     if (sound_avail&MUSIC_INITIALIZED)
  1338.     {
  1339.       if (current_song) { current_song->stop(); delete current_song; }
  1340.       current_song=new song("music/intro.hmi");
  1341.       current_song->play(music_volume);
  1342.     }
  1343.  
  1344.     void *logo_snd=symbol_value(make_find_symbol("LOGO_SND"));
  1345.  
  1346.     if (DEFINEDP(logo_snd) && (sound_avail&SFX_INITIALIZED))
  1347.       cash.sfx(lnumber_value(logo_snd))->play(sfx_volume);
  1348.  
  1349.     image blank(2,2); blank.clear();
  1350.     eh->set_mouse_shape(blank.copy(),0,0);      // don't show mouse
  1351.     fade_in(cash.img(cdc_logo),32);
  1352.     
  1353.     milli_wait(900);
  1354.  
  1355.     void *space_snd=symbol_value(make_find_symbol("SPACE_SND"));
  1356.  
  1357.     fade_out(32);
  1358.     milli_wait(300);
  1359.  
  1360.     int i,abort=0;
  1361.     char *str=lstring_value(eval(make_find_symbol("plot_start")));
  1362.     
  1363.     bFILE *fp=open_file("art/smoke.spe","rb");
  1364.     if (!fp->open_failure())
  1365.     {
  1366.       spec_directory sd(fp);
  1367.       palette *old_pal=pal;
  1368.       pal=new palette(sd.find(SPEC_PALETTE),fp);
  1369.       pal->shift(1);
  1370.  
  1371.       image *gray=new image(sd.find("gray_pict"),fp);
  1372.       image *smoke[5];
  1373.  
  1374.       char nm[20];
  1375.       for (i=0;i<5;i++)
  1376.       {
  1377.         sprintf(nm,"smoke%04d.pcx",i+1);
  1378.         smoke[i]=new image(sd.find(nm),fp);
  1379.       }
  1380.  
  1381.       screen->clear();
  1382.       pal->load();
  1383.  
  1384.       int dx=(xres+1)/2-gray->width()/2,dy=(yres+1)/2-gray->height()/2;
  1385.       gray->put_image(screen,dx,dy);
  1386.       smoke[0]->put_image(screen,dx+24,dy+5);
  1387.  
  1388.       fade_in(NULL,16);
  1389.       uchar cmap[32];
  1390.       for (i=0;i<32;i++)
  1391.         cmap[i]=pal->find_closest(i*256/32,i*256/32,i*256/32);
  1392.  
  1393.       event ev; ev.type=EV_SPURIOUS;
  1394.       time_marker start;
  1395.  
  1396.  
  1397.       for (i=0;i<600 && ev.type!=EV_KEY && ev.type!=EV_MOUSE_BUTTON;i++)
  1398.       {
  1399.         gray->put_part(screen,dx,dy,0,0,319,199);
  1400.         smoke[i%5]->put_image(screen,dx+65,dy+70);
  1401.         text_draw(205-i,dx+15,dy,dx+320-15,dy+199,str,eh->font(),cmap,eh->bright_color());
  1402.         eh->flush_screen();
  1403.         time_marker now;
  1404.         while (now.diff_time(&start)<0.15) 
  1405.           now.get_time();
  1406.         start.get_time();
  1407.             
  1408.         while (eh->event_waiting() && ev.type!=EV_KEY) eh->get_event(ev);
  1409.         if ((i%5)==0 && DEFINEDP(space_snd) && (sound_avail&SFX_INITIALIZED))
  1410.           cash.sfx(lnumber_value(space_snd))->play(sfx_volume*90/127);
  1411.       }
  1412.  
  1413.       the_game->reset_keymap();
  1414.  
  1415.       fade_out(16);
  1416.  
  1417.       for (i=0;i<5;i++) delete smoke[i];
  1418.       delete gray;
  1419.  
  1420.       delete pal;
  1421.       pal=old_pal;
  1422.     }
  1423.     delete fp;
  1424.  
  1425.     for (i=0;i<100 && !abort;i++)
  1426.     {
  1427.       
  1428.     }
  1429.  
  1430.  
  1431.  
  1432.     if (title_screen>=0)
  1433.       fade_in(cash.img(title_screen),32);
  1434.  
  1435.     eh->set_mouse_shape(cash.img(c_normal)->copy(),1,1);
  1436.   }
  1437. }
  1438.  
  1439. extern int start_edit;
  1440.  
  1441. void game::request_end()
  1442. {
  1443.   req_end=1;
  1444. }
  1445.  
  1446. extern void fast_load_start_recording(char *name);
  1447. extern void fast_load_stop_recording();
  1448. extern void fast_load_start_reloading(char *name);
  1449. extern void fast_load_stop_reloading();
  1450.  
  1451. game::game(int argc, char **argv)
  1452. {
  1453.   int i;
  1454.   req_name[0]=0;
  1455.   bg_xmul=bg_ymul=1;
  1456.   bg_xdiv=bg_ydiv=8;
  1457.   last_input=NULL;
  1458.   current_level=NULL;
  1459.   refresh=1;  
  1460.   the_game=this;  
  1461.   top_menu=joy_win=NULL;
  1462.   old_view=first_view=NULL;
  1463.   nplayers=1;
  1464.  
  1465.   help_text_frames=0;  
  1466.   strcpy(help_text,"");
  1467.  
  1468.   for (i=1;i<argc;i++)
  1469.     if (!strcmp(argv[i],"-no_delay"))
  1470.     {
  1471.       no_delay=1;
  1472.       dprintf("Frame delay off (-nodelay)\n");
  1473.     }
  1474.   
  1475.   image_init();  
  1476.   zoom=15;  
  1477.   no_delay=0;
  1478.  
  1479.   if (get_option("-use_joy"))  
  1480.   {
  1481.     has_joystick=joy_init(argc,argv);
  1482.     dprintf("Joystick : ");
  1483.     if (has_joystick) dprintf("detected\n");
  1484.     else dprintf("not detected\n");
  1485.   }
  1486.   else has_joystick=0;
  1487.  
  1488.   //    fast_load_start_recording("fastload.dat");
  1489.   load_data(argc,argv);  
  1490.   //    fast_load_stop_recording();
  1491.  
  1492.   get_key_bindings();
  1493.  
  1494.  
  1495.   reset_keymap();                   // we think all the keys are up right now
  1496.   finished=0;
  1497.  
  1498.   calc_light_table(pal);
  1499.  
  1500.   if (current_level==NULL && net_start())  // if we joined a net game get level from server
  1501.   {
  1502.     if (!request_server_entry())
  1503.     {
  1504.       exit(0);
  1505.     }
  1506.     net_reload();
  1507.     //    load_level(NET_STARTFILE); 
  1508.   }
  1509.  
  1510.  
  1511.   if (get_option("-2") && (xres<639 || yres<399))
  1512.   {
  1513.     close_graphics();
  1514.     dprintf("Resolution must be > 640x400 to use -2 option\n");    
  1515.     exit(0);
  1516.   }
  1517.   pal->load();
  1518.   
  1519.   recalc_local_view_space();   // now that we know what size the screen is...
  1520.  
  1521.   dark_color=get_color(cash.img(window_colors)->pixel(2,0));
  1522.   bright_color=get_color(cash.img(window_colors)->pixel(0,0));
  1523.   med_color=get_color(cash.img(window_colors)->pixel(1,0));
  1524.  
  1525.   morph_dark_color=get_color(cash.img(window_colors)->pixel(2,1));
  1526.   morph_bright_color=get_color(cash.img(window_colors)->pixel(0,1));
  1527.   morph_med_color=get_color(cash.img(window_colors)->pixel(1,1));
  1528.   morph_sel_frame_color=pal->find_closest(255,255,0);
  1529.   light_connection_color=morph_sel_frame_color;
  1530.  
  1531.   if (NILP(symbol_value(l_default_font)))
  1532.   {
  1533.     dprintf("No font defined, set symbol default-font to an image name\n");
  1534.     exit(0);
  1535.   }
  1536.  
  1537.   int font_pict=big_font_pict;
  1538.   
  1539.   if (console_font_pict==-1) console_font_pict=font_pict;
  1540.   game_font=new JCFont(cash.img(big_font_pict));
  1541.   window_font=new JCFont(cash.img(small_font_pict));
  1542.  
  1543.   console_font=new JCFont(cash.img(console_font_pict));
  1544.  
  1545.   eh=new window_manager(screen,pal,bright_color,
  1546.       med_color,
  1547.       dark_color,
  1548.       game_font);  
  1549.   idle_man=new idle_manager;
  1550.  
  1551.  
  1552.   eh->set_frame_font(window_font);
  1553.  
  1554.   chat=new chat_console(eh,console_font,50,6);
  1555.  
  1556.   if (!eh->has_mouse())
  1557.   {
  1558.     close_graphics();
  1559.     image_uninit();
  1560.     dprintf("No mouse driver detected, please rectify.\n");
  1561.     exit(0);
  1562.   }
  1563.  
  1564.   gamma_correct(pal);
  1565.  
  1566.   if (main_net_cfg==NULL || (main_net_cfg->state!=net_configuration::SERVER &&
  1567.       main_net_cfg->state!=net_configuration::CLIENT))
  1568.   {
  1569.     if (!start_edit && !net_start())
  1570.       do_title();
  1571.   } else if (main_net_cfg && main_net_cfg->state==net_configuration::SERVER)
  1572.   {
  1573.     the_game->load_level(level_file);
  1574.     start_running=1;
  1575.   }
  1576.     
  1577.   dev|= DRAW_FG_LAYER | DRAW_BG_LAYER | DRAW_PEOPLE_LAYER | DRAW_HELP_LAYER | DRAW_LIGHTS | DRAW_LINKS;
  1578.  
  1579.   if (dev & EDIT_MODE)
  1580.     set_frame_size(0);
  1581.   //  do_intro();
  1582.   state=START_STATE;         // first set the state to one that has windows
  1583.  
  1584.   if (start_running)
  1585.     set_state(RUN_STATE);
  1586.   else
  1587.   {
  1588.     screen->clear();  
  1589.     if (title_screen>=0)
  1590.     {
  1591.       image *tit=cash.img(title_screen);
  1592.       tit->put_image(screen,screen->width()/2-tit->width()/2,
  1593.           screen->height()/2-tit->height()/2);
  1594.     }   
  1595.     set_state(MENU_STATE);   // then go to menu state so windows will turn off
  1596.   }
  1597. }
  1598.  
  1599.  
  1600.  
  1601. time_marker *led_last_time=NULL,*fps_mark_start=NULL;
  1602. double avg_fps=15.0,possible_fps=15.0;
  1603.  
  1604. void game::toggle_delay()
  1605. {
  1606.   no_delay=!no_delay;
  1607.   if (no_delay)
  1608.     show_help(symbol_str("delay_off"));
  1609.   else show_help(symbol_str("delay_on"));
  1610.   avg_fps=possible_fps=15.0;
  1611. }
  1612.  
  1613. void game::show_time()
  1614. {
  1615.   if (first_view && fps_on)
  1616.   {
  1617.     char str[10];
  1618.     sprintf(str,"%d",(long)(avg_fps*10.0));
  1619.     console_font->put_string(screen,first_view->cx1,first_view->cy1,str);
  1620.  
  1621.     sprintf(str,"%d",total_active);
  1622.     console_font->put_string(screen,first_view->cx1,first_view->cy1+10,str);
  1623.   }
  1624.  
  1625. #ifdef MAC_PROFILE
  1626.   for (int i=0; i<KJCOUNTERS; i++)
  1627.     console_font->put_string(screen,10,8*i+8,kjfie[i]); // kill me
  1628. #endif
  1629. }
  1630.  
  1631. void game::update_screen()
  1632. {
  1633.   if (state==HELP_STATE)
  1634.     draw_help();
  1635.   else if (current_level)
  1636.   {    
  1637.     if (!(dev & EDIT_MODE) || refresh)    
  1638.     {    
  1639.       view *f=first_view;
  1640.       current_level->clear_active_list();
  1641.       for (;f;f=f->next)
  1642.       {
  1643.         if (f->focus)           
  1644.         {
  1645.           int w,h;
  1646.             
  1647.           w=(f->cx2-f->cx1+1);
  1648.           h=(f->cy2-f->cy1+1);
  1649.             
  1650.           total_active+=current_level->add_drawables(f->xoff()-w/4,f->yoff()-h/4,
  1651.               f->xoff()+w+w/4,f->yoff()+h+h/4);
  1652.             
  1653.         }
  1654.       }
  1655.  
  1656.       for (f=first_view;f;f=f->next)
  1657.       {
  1658.         if (f->drawable())
  1659.         {
  1660.           StartTime(5); // kill me
  1661.           if (interpolate_draw)
  1662.           {
  1663.             draw_map(f,1);
  1664.             eh->flush_screen();
  1665.           }
  1666.           draw_map(f,0);
  1667.           DiffTime("    Drawmap",5); // kill me
  1668.         }
  1669.       }
  1670.  
  1671.     }  
  1672.     if (state==PAUSE_STATE)
  1673.     {
  1674.       for (view *f=first_view;f;f=f->next)
  1675.         cash.img(pause_image)->put_image(screen,(f->cx1+f->cx2)/2-cash.img(pause_image)->width()/2,
  1676.             f->cy1+5,1);
  1677.     }
  1678.     
  1679.     show_time();
  1680.   }
  1681.  
  1682.   if (state==RUN_STATE && cash.prof_is_on())
  1683.     cash.prof_poll_end();
  1684.  
  1685.   StartTime(16); //kill me
  1686.   eh->flush_screen();
  1687.   DiffTime("    Flush",16); //kill me
  1688. }
  1689.  
  1690. void game::do_intro()
  1691. {
  1692.  
  1693. }
  1694.  
  1695. #if 1
  1696. int game::calc_speed()
  1697. {
  1698.   int ret=0;
  1699.   if (fps_mark_start)
  1700.   {
  1701.  
  1702.     time_marker t;
  1703.  
  1704.     // find average fps for last 10 frames
  1705.     double td=t.diff_time(fps_mark_start);
  1706.     if (td<0.001)     // something is rotten in the state of demark
  1707.       td=0.001;
  1708.  
  1709.     avg_fps=avg_fps*9.0/10.0+1.0/(td*10.0);  
  1710.     possible_fps=possible_fps*9.0/10.0+1.0/(td*10.0);  
  1711.  
  1712.     if (avg_fps>14)
  1713.     {
  1714.       if (massive_frame_panic>20)
  1715.         massive_frame_panic=20;
  1716.       else if (massive_frame_panic)
  1717.         massive_frame_panic--;
  1718.     }
  1719.  
  1720.     if (avg_fps>15 && ((dev&EDIT_MODE)==0 || need_delay))
  1721.     {
  1722.       frame_panic=0;
  1723.       long stime=(long)((1/15.0-1.0/possible_fps)*1000.0); 
  1724.       if (stime>0 && !no_delay)
  1725.       {
  1726.         milli_wait(stime);
  1727.         avg_fps-=1.0/(td*10.0);        // subtract out old estimate
  1728.             
  1729.         time_marker t;
  1730.                 
  1731.         // find average fps for last 10 frames
  1732.         double td=t.diff_time(fps_mark_start);
  1733.         if (td<0.00001)     // something is rotten in the state of demark
  1734.           td=0.00001;
  1735.             
  1736.         avg_fps+=1.0/(td*10.0);       // add in new estimate
  1737.       }
  1738.     } else if (avg_fps<14)
  1739.     {
  1740.       if (avg_fps<10)
  1741.         massive_frame_panic++;
  1742.       frame_panic++;
  1743.       ret=1;
  1744.     }
  1745.     
  1746.     delete fps_mark_start;    
  1747.   }
  1748.   fps_mark_start=new time_marker;
  1749.   return ret;
  1750. }
  1751. #else
  1752. int game::calc_speed()
  1753. {
  1754.   static UnsignedWide last_t = {0,0};
  1755.   UnsignedWide t;
  1756.     
  1757.   if (dev & EDIT_MODE)
  1758.     return 0;
  1759.     
  1760.   do 
  1761.   {
  1762.     Microseconds(&t);
  1763.   } while( t.lo - last_t.lo < 60000);
  1764.     
  1765.   last_t = t;
  1766.     
  1767.   return 0;
  1768. }
  1769. #endif
  1770.  
  1771. extern int start_edit;
  1772.  
  1773. void single_render();
  1774. void double_render();
  1775.  
  1776. void game::get_input()
  1777. {
  1778.   event ev;  
  1779.   idle_ticks++;
  1780.   while (event_waiting(eh))
  1781.   {
  1782.     get_event(ev,eh);
  1783.  
  1784.     if (ev.type==EV_MOUSE_MOVE) last_input=ev.window;
  1785.     // don't process repeated keys in the main window, it will slow down the game handle such
  1786.     // useless events. However in other windows it might be useful, such as in input windows
  1787.     // where you want to repeatedly scroll down..
  1788.     if (ev.type!=EV_KEY || !key_down(ev.key) || ev.window || (dev&EDIT_MODE))
  1789.     {
  1790.       if (ev.type==EV_KEY)     
  1791.       {
  1792.         set_key_down(ev.key,1);
  1793.         if (playing_state(state))
  1794.         {     
  1795.           if (ev.key<256)
  1796.           {
  1797.             if (chat && chat->chat_event(ev))
  1798.               base->packet.write_byte(SCMD_CHAT_KEYPRESS);
  1799.             else
  1800.               base->packet.write_byte(SCMD_KEYPRESS);
  1801.           }
  1802.           else
  1803.             base->packet.write_byte(SCMD_EXT_KEYPRESS);
  1804.           base->packet.write_byte(client_number());
  1805.           if (ev.key>256)
  1806.             base->packet.write_byte(ev.key-256);
  1807.           else
  1808.             base->packet.write_byte(ev.key);      
  1809.         }
  1810.       }
  1811.       else if (ev.type==EV_KEYRELEASE)
  1812.       {
  1813.         set_key_down(ev.key,0);
  1814.         if (playing_state(state))
  1815.         {     
  1816.           if (ev.key<256)
  1817.             base->packet.write_byte(SCMD_KEYRELEASE);
  1818.           else
  1819.             base->packet.write_byte(SCMD_EXT_KEYRELEASE);
  1820.           base->packet.write_byte(client_number());
  1821.           if (ev.key>255)
  1822.             base->packet.write_byte(ev.key-256);
  1823.           else
  1824.             base->packet.write_byte(ev.key);      
  1825.         }    
  1826.       }
  1827.       
  1828.       if ((dev&EDIT_MODE) || start_edit || ev.type==EV_MESSAGE)
  1829.         dev_cont->handle_event(ev);
  1830.  
  1831.       view *v=first_view;
  1832.       for (;v;v=v->next)
  1833.         if (v->local_player() && v->handle_event(ev))
  1834.           ev.type=EV_SPURIOUS;       // if the event was used by the view, gobble it up
  1835.  
  1836.  
  1837.       
  1838.       help_handle_event(ev);    
  1839.       mousex=last_demo_mx;
  1840.       mousey=last_demo_my;
  1841.  
  1842.       if (ev.type==EV_MESSAGE)
  1843.       {
  1844.         switch (ev.message.id)
  1845.         {
  1846.           case CALB_JOY : 
  1847.           { 
  1848.             if (!joy_win)
  1849.             {
  1850.               int wx=WINDOW_FRAME_LEFT,wy=WINDOW_FRAME_TOP;
  1851.                       
  1852.               joy_win=eh->new_window(80,50,-1,-1,
  1853.                   new button(wx+70,wy+9,JOY_OK,"OK",
  1854.                       new info_field(wx,wy+30,DEV_NULL,
  1855.                           " Center joystick and\n"
  1856.                           "press the fire button",NULL)),
  1857.             
  1858.                   "Joystick");
  1859.               set_state(JOY_CALB_STATE); 
  1860.             }
  1861.           }
  1862.           case TOP_MENU :
  1863.           { menu_select(ev); } break;
  1864.           case DEV_QUIT :
  1865.           { finished=1; } break;
  1866.             
  1867.         }
  1868.       }        
  1869.       else if (ev.type==EV_CLOSE_WINDOW && ev.window==top_menu)
  1870.       {
  1871.         eh->close_window(top_menu);
  1872.         top_menu=NULL;
  1873.       }
  1874.     
  1875.       switch (state)
  1876.       {
  1877.         case JOY_CALB_STATE :
  1878.         { joy_calb(ev); } break;
  1879.         case INTRO_START_STATE : 
  1880.         { do_intro(); 
  1881.         if (dev & EDIT_MODE)
  1882.           set_state(RUN_STATE);
  1883.         else
  1884.           set_state(MENU_STATE); 
  1885.         } break;     
  1886.         case PAUSE_STATE : if (ev.type==EV_KEY && (ev.key==JK_SPACE || ev.key==JK_ENTER)) 
  1887.         { set_state(RUN_STATE); } break;
  1888.         case RUN_STATE : 
  1889.         {
  1890.           if (ev.window==NULL)
  1891.           {
  1892.                   
  1893.             switch (ev.type)
  1894.             {
  1895.               case EV_KEY : 
  1896.               { switch (ev.key)
  1897.               {
  1898.                 case 'm' : 
  1899.                 { 
  1900.                   if (dev&MAP_MODE) dev-=MAP_MODE;
  1901.                   else if ((player_list && player_list->next) || dev&EDIT_MODE) dev|=MAP_MODE;
  1902.                 
  1903.                   if (!(dev&MAP_MODE))
  1904.                   {
  1905.                     if (dev_cont->tbw) dev_cont->toggle_toolbar();
  1906.                     edit_mode=ID_DMODE_DRAW;
  1907.                   }
  1908.                   need_refresh();     
  1909.                 } break;
  1910.                 case 'v' : 
  1911.                 { eh->push_event(new event(DO_VOLUME,NULL)); } break;
  1912.                 case 'p' : 
  1913.                 { if (!(dev&EDIT_MODE) && (!main_net_cfg || 
  1914.                     (main_net_cfg->state!=net_configuration::SERVER &&
  1915.                         main_net_cfg->state!=net_configuration::CLIENT)))  
  1916.                   set_state(PAUSE_STATE); 
  1917.                 } break;
  1918.                 case 'S' : 
  1919.                   if (start_edit)
  1920.                   { eh->push_event(new event(ID_LEVEL_SAVE,NULL)); } break;
  1921.                 case JK_TAB : 
  1922.                 { if (start_edit) toggle_edit_mode(); need_refresh(); } break;
  1923.                 case 'c' :          
  1924.                 { if (chatting_enabled && (!(dev&EDIT_MODE) && chat))
  1925.                   chat->toggle();
  1926.                 } break;
  1927.                 case '9' : 
  1928.                 { dev=dev^PERFORMANCE_TEST_MODE; need_refresh(); } break;
  1929.                 
  1930.                 /*
  1931.                   case '=' :
  1932.                   case '+' : 
  1933.                   { if (!dev_cont->need_plus_minus())
  1934.                   { 
  1935.                   if (eh->key_pressed(JK_CTRL_L))
  1936.                   grow_views(20);
  1937.                   else
  1938.                   grow_views(5); 
  1939.                   draw(state==SCENE_STATE);
  1940.                   }
  1941.                   } break;
  1942.                   case JK_F10 : make_screen_size(311,160); break;
  1943.                   case '_' :
  1944.                   case '-' : 
  1945.                   {
  1946.                   if (!dev_cont->need_plus_minus())            
  1947.                   { 
  1948.                   if (eh->key_pressed(JK_CTRL_L))
  1949.                   grow_views(-20);
  1950.                   else
  1951.                   grow_views(-5); 
  1952.                   draw(state==SCENE_STATE); 
  1953.                   } 
  1954.                   } break; */
  1955.                 
  1956.               }
  1957.             } break;            
  1958.               case EV_RESIZE : 
  1959.               { 
  1960.                 view *v;
  1961.                 for (v=first_view;v;v=v->next)  // see if any views need to change size
  1962.                 {
  1963.                   if (v->local_player())
  1964.                   {
  1965.                     int w=(xres-10)/(small_render ? 2 : 1);
  1966.                     int h=(yres-10)/(small_render ? 2 : 1);
  1967.                 
  1968.                     /*                    v->suggest.send_view=1;
  1969.                     v->suggest.cx1=5;
  1970.                     v->suggest.cx2=5+w;
  1971.                     v->suggest.cy1=5;
  1972.                     v->suggest.cy2=5+h;
  1973.                     v->suggest.pan_x=v->pan_x;
  1974.                     v->suggest.pan_y=v->pan_y;
  1975.                     v->suggest.shift_down=v->shift_down;
  1976.                     v->suggest.shift_right=v->shift_right; */
  1977.                   }          
  1978.                 }
  1979.                 draw(); 
  1980.               } break;
  1981.               case EV_REDRAW : 
  1982.                 screen->add_dirty(ev.redraw.x1,ev.redraw.y1,
  1983.                     ev.redraw.x2,ev.redraw.y2); 
  1984.                 break;
  1985.               case EV_MESSAGE :        
  1986.                 switch (ev.message.id)
  1987.                 {
  1988.                   case RAISE_SFX :
  1989.                   case LOWER_SFX :
  1990.                   case RAISE_MUSIC :
  1991.                   case LOWER_MUSIC :
  1992.                     if (ev.message.id==RAISE_SFX && sfx_volume!=127) sfx_volume=min(127,sfx_volume+16);
  1993.                     if (ev.message.id==LOWER_SFX && sfx_volume!=0) sfx_volume=max(sfx_volume-16,0);
  1994.                     if (ev.message.id==RAISE_MUSIC && music_volume!=126) 
  1995.                     {            
  1996.                       music_volume=min(music_volume+16,127);
  1997.                       if (current_song && (sound_avail&MUSIC_INITIALIZED))
  1998.                         current_song->set_volume(music_volume);
  1999.                     }
  2000.               
  2001.                     if (ev.message.id==LOWER_MUSIC && music_volume!=0) 
  2002.                     {            
  2003.                       music_volume=max(music_volume-16,0);
  2004.                       if (current_song && (sound_avail&MUSIC_INITIALIZED))
  2005.                         current_song->set_volume(music_volume);
  2006.                     }            
  2007.               
  2008.                     ((button *)ev.message.data)->push();          
  2009.                     break;
  2010.                 }
  2011.                       
  2012.             }
  2013.           }
  2014.           } break;
  2015.       }
  2016.     }
  2017.   }
  2018. }
  2019.  
  2020.  
  2021. void net_send(int force=0)
  2022. {
  2023.   if ( (!(dev&EDIT_MODE)) || force)
  2024.   {
  2025.     if (demo_man.state==demo_manager::PLAYING)
  2026.     {
  2027.       base->input_state=INPUT_PROCESSING;
  2028.     } else
  2029.     {
  2030.       
  2031.  
  2032.  
  2033.       if (!player_list->focus)
  2034.       {
  2035.         dprintf("Players have not been created\ncall create_players");
  2036.         exit(0);
  2037.       }
  2038.  
  2039.  
  2040.       view *p=player_list;
  2041.       for (;p;p=p->next)
  2042.         if (p->local_player())
  2043.           p->get_input();
  2044.  
  2045.  
  2046.       base->packet.write_byte(SCMD_SYNC);
  2047.       base->packet.write_short(make_sync());
  2048.  
  2049.       if (base->join_list)
  2050.         base->packet.write_byte(SCMD_RELOAD);
  2051.  
  2052.       //      dprintf("save tick %d, pk size=%d, rand_on=%d, sync=%d\n",current_level->tick_counter(),
  2053.       //         base->packet.packet_size(),rand_on,make_sync());
  2054.       send_local_request();
  2055.     }
  2056.   }
  2057. }
  2058.  
  2059. void net_receive()
  2060. {
  2061.   if (!(dev&EDIT_MODE) && current_level)
  2062.   {
  2063.     uchar buf[PACKET_MAX_SIZE+1];
  2064.     int size;
  2065.  
  2066.     if (demo_man.state==demo_manager::PLAYING)
  2067.     { 
  2068.       if (!demo_man.get_packet(buf,size))
  2069.         size=0;
  2070.       base->packet.packet_reset();
  2071.       base->mem_lock=0;
  2072.     } else
  2073.     {
  2074.       size=get_inputs_from_server(buf);
  2075.       if (demo_man.state==demo_manager::RECORDING)
  2076.         demo_man.save_packet(buf,size);
  2077.     }
  2078.  
  2079.     process_packet_commands(buf,size);
  2080.   }
  2081. }
  2082.  
  2083. void game::step()
  2084. {
  2085.   clear_tmp();
  2086.   if (current_level)
  2087.   {
  2088.     current_level->unactivate_all();
  2089.     total_active=0;
  2090.     for (view *f=first_view;f;f=f->next)
  2091.     {
  2092.       if (f->focus)           
  2093.       {
  2094.         f->update_scroll();
  2095.         int w,h;
  2096.             
  2097.         w=(f->cx2-f->cx1+1);
  2098.         h=(f->cy2-f->cy1+1);
  2099.         total_active+=current_level->add_actives(f->xoff()-w/4,f->yoff()-h/4,
  2100.             f->xoff()+w+w/4,f->yoff()+h+h/4);
  2101.       }
  2102.     }
  2103.   }
  2104.  
  2105.   if (state==RUN_STATE)
  2106.   {    
  2107.     if ((dev&EDIT_MODE) || (main_net_cfg && (main_net_cfg->state==net_configuration::CLIENT ||
  2108.         main_net_cfg->state==net_configuration::SERVER)))
  2109.       idle_ticks=0;
  2110.  
  2111.     if (demo_man.current_state()==demo_manager::NORMAL && idle_ticks>420 && demo_start)
  2112.     {
  2113.       idle_ticks=0;
  2114.       set_state(MENU_STATE);    
  2115.     }
  2116.     else if (!(dev & EDIT_MODE))               // if edit mode, then don't step anything
  2117.     {
  2118. #ifdef __MAC__
  2119.       if (key_down(JK_ESC) || (key_down('q') && key_down(JK_COMMAND)))
  2120. #else
  2121.         if (key_down(JK_ESC))
  2122. #endif
  2123.         {
  2124.           set_state(MENU_STATE);
  2125.           set_key_down(JK_ESC,0);
  2126.           return;
  2127.         }
  2128.       ambient_ramp=0;
  2129.       view *v;
  2130.       for (v=first_view;v;v=v->next)
  2131.         v->update_scroll();
  2132.  
  2133.       cash.prof_poll_start();
  2134.       current_level->tick();
  2135.       sbar.step();
  2136.     } else    
  2137.       dev_scroll();  
  2138.   } else if (state==JOY_CALB_STATE)
  2139.   {
  2140.     event ev;
  2141.     joy_calb(ev);
  2142.   } else if (state==MENU_STATE)  
  2143.     main_menu();  
  2144.     
  2145.   if (key_down('x') && (key_down(JK_ALT_L) || key_down(JK_ALT_R)) && confirm_quit()) finished=1;
  2146. }
  2147.  
  2148. extern void *current_demo;
  2149.  
  2150. game::~game()
  2151. {  
  2152.   delete idle_man;
  2153.   idle_man=0;
  2154.  
  2155.   current_demo=NULL;
  2156.   if (first_view==player_list) first_view=NULL;
  2157.   while (player_list)
  2158.   {
  2159.     view *p=player_list;
  2160.     game_object *o=p->focus;
  2161.     player_list=player_list->next;
  2162.     delete p;
  2163.     o->set_controller(NULL);
  2164.     if (current_level && o)
  2165.       current_level->delete_object(o);
  2166.     else delete o;
  2167.   }
  2168.  
  2169.   if (current_level) { delete current_level; current_level=NULL; }
  2170.  
  2171.   if (first_view!=player_list)
  2172.   {
  2173.     while (player_list)
  2174.     {
  2175.       view *p=player_list;
  2176.       player_list=player_list->next;
  2177.       delete p;
  2178.     }
  2179.   }
  2180.  
  2181.   while (first_view)
  2182.   {
  2183.     view *p=first_view;
  2184.     first_view=first_view->next;
  2185.     delete p;
  2186.   }
  2187.  
  2188.   player_list=NULL;  
  2189.  
  2190.   if (old_view)
  2191.   {
  2192.     first_view=old_view;
  2193.     while (first_view)
  2194.     {
  2195.       view *p=first_view;
  2196.       first_view=first_view->next;
  2197.       delete p;
  2198.     }
  2199.   }
  2200.   old_view=NULL;
  2201.  
  2202.   int i=0;
  2203.   for (;i<total_objects;i++)
  2204.   {
  2205.     jfree(object_names[i]);
  2206.     delete figures[i];
  2207.   }
  2208.   if (fps_mark_start) delete fps_mark_start; fps_mark_start=NULL;
  2209.   delete pal;
  2210.   jfree(object_names);
  2211.   jfree(figures);
  2212.  
  2213.   jfree(backtiles);
  2214.   jfree(foretiles);
  2215.   if (total_weapons)
  2216.     jfree(weapon_types);
  2217.  
  2218.   config_cleanup();
  2219.   delete color_table;
  2220.   delete eh;
  2221.   delete game_font;
  2222.   delete window_font;
  2223.   delete big_font;
  2224.   delete console_font;
  2225.   if (total_help_screens)
  2226.     jfree(help_screens);
  2227.     
  2228.  
  2229.   //  image_uninit();
  2230. }
  2231.  
  2232.  
  2233.  
  2234. void game::draw(int scene_mode)
  2235. {
  2236.   screen->add_dirty(0,0,xres,yres);
  2237.   image *bt=cash.img(border_tile);
  2238.   int tw=bt->width(),th=bt->height(),dx,dy=0;
  2239.   int xt=screen->width()/tw+1,yt=screen->height()/th+1,x,y;
  2240.   screen->clear();
  2241.   //  for (y=0;y<yt;y++,dy+=th)
  2242.   //    for (x=0,dx=0;x<xt;x++,dx+=tw)
  2243.   //      bt->put_image(screen,dx,dy); 
  2244.   int lr=eh->bright_color(),
  2245.     mr=eh->medium_color();
  2246.  
  2247.   if (scene_mode)
  2248.   {
  2249.     char *helpstr="ARROW KEYS CHANGE TEXT SPEED";
  2250.     eh->font()->put_string(screen,screen->width()/2-(eh->font()->width()*strlen(helpstr))/2+1,
  2251.         screen->height()-eh->font()->height()-5+1,helpstr,eh->dark_color());    
  2252.     eh->font()->put_string(screen,screen->width()/2-(eh->font()->width()*strlen(helpstr))/2,
  2253.         screen->height()-eh->font()->height()-5,helpstr,eh->bright_color());    
  2254.   }
  2255.   /*  else
  2256.       {
  2257.       char *helpstr="PRESS h FOR HELP";
  2258.       eh->font()->put_string(screen,screen->width()-eh->font()->width()*strlen(helpstr)-5,
  2259.       screen->height()-eh->font()->height()-5,helpstr);
  2260.       }*/
  2261.   /*  int dc=cash.img(window_colors)->pixel(0,2);
  2262.       int mc=cash.img(window_colors)->pixel(1,2);
  2263.       int bc=cash.img(window_colors)->pixel(2,2);
  2264.       screen->line(0,0,screen->width()-1,0,dc);
  2265.       screen->line(0,0,0,screen->height()-1,dc);
  2266.       screen->line(0,screen->height()-1,screen->width()-1,screen->height()-1,bc);
  2267.       screen->line(screen->width()-1,0,screen->width()-1,screen->height()-1,bc);*/
  2268.   for (view *f=first_view;f;f=f->next)
  2269.     draw_map(f,0);
  2270.  
  2271.   sbar.redraw(screen);
  2272. }
  2273.  
  2274. int external_print=0;
  2275.  
  2276. void start_sound(int argc, char **argv)
  2277. {
  2278.   sfx_volume=music_volume=127;
  2279.  
  2280.   for (int i=1;i<argc;i++)
  2281.     if (!strcmp(argv[i],"-sfx_volume"))
  2282.     {
  2283.       i++;
  2284.       if (atoi(argv[i])>=0 && atoi(argv[i])<127)
  2285.         sfx_volume=atoi(argv[i]);
  2286.       else dprintf("Bad sound effects volume level, use 0..127\n");      
  2287.     }
  2288.     else if (!strcmp(argv[i],"-music_volume"))
  2289.     {
  2290.       i++;
  2291.       if (atoi(argv[i])>=0 && atoi(argv[i])<127)
  2292.         music_volume=atoi(argv[i]);
  2293.       else dprintf("Bad music volume level, use 0..127\n");      
  2294.     }
  2295.  
  2296.   sound_avail=sound_init(argc,argv);
  2297. }
  2298.  
  2299. void game_printer(char *st)
  2300. {
  2301.  
  2302. #if 1
  2303.     static FILE *f = 0;
  2304.     if (!f)
  2305.         f = fopen("abuse.out","wt");
  2306.     fprintf(f,st);
  2307.     fflush(f);
  2308. #endif
  2309.  
  2310.   if (dev_console && !external_print)
  2311.   {
  2312.     dev_console->put_string(st);
  2313.   }
  2314.  
  2315. #ifndef __MAC__
  2316.   else fprintf(stderr,"%s",st);
  2317. #endif
  2318. }
  2319.  
  2320.  
  2321. void game_getter(char *st, int max)
  2322. {
  2323.   if (!max) return ;
  2324.   max--;
  2325.   *st=0;
  2326.   if (dev_console && !external_print)
  2327.   {    
  2328.     dev_console->show();
  2329.     int t=0;
  2330.     event ev;
  2331.     do
  2332.     {
  2333.       get_event(ev,eh);
  2334.       if (ev.type==EV_KEY)
  2335.       {
  2336.         if (ev.key==JK_BACKSPACE)
  2337.         {
  2338.           if (t) 
  2339.           {
  2340.             dev_console->printf("%c",ev.key);
  2341.             t--;
  2342.             st--;
  2343.             *st=0;
  2344.             max++;
  2345.           }
  2346.         } else if (ev.key>=' ' && ev.key<='~')
  2347.         {
  2348.           dev_console->printf("%c",ev.key);
  2349.           *st=ev.key;
  2350.           t++;
  2351.           max--;
  2352.           st++;
  2353.           *st=0;
  2354.         }              
  2355.       }
  2356.       eh->flush_screen();
  2357.     } while (ev.type!=EV_KEY || ev.key!=JK_ENTER);    
  2358.     dprintf("\n");
  2359.   }
  2360.   else 
  2361.   {
  2362.     if (fgets(st,max,stdin))
  2363.     {
  2364.       if (*st)
  2365.         st[strlen(st)-1]=0;
  2366.     }
  2367.   }
  2368. }
  2369.  
  2370.  
  2371. void show_startup()
  2372. {
  2373.   show_verinfo(start_argc,start_argv);
  2374. }
  2375.  
  2376. char *get_line(int open_braces)
  2377. {
  2378.   char *line=(char *)jmalloc(1000,"lstring");
  2379.   fgets(line,1000,stdin);
  2380.  
  2381.   char prev=' ';
  2382.   for (char *s=line;*s && (prev!=' ' || *s!=';');s++)
  2383.   {
  2384.     prev=*s;
  2385.     if (*s=='(') open_braces++;
  2386.     else if (*s==')') open_braces--;
  2387.   }
  2388.   if (open_braces<0)    
  2389.     dprintf("\nToo many )'s\n");
  2390.   else if (open_braces>0)
  2391.   {
  2392.     char *s2=get_line(open_braces);
  2393.     line=(char *)jrealloc(line,strlen(line)+strlen(s2)+1,"lstring");
  2394.     strcat(line,s2);
  2395.     jfree(s2);    
  2396.   }  
  2397.   return line;
  2398. }
  2399.  
  2400. void check_for_upgrade(int argc, char **argv)
  2401. {
  2402.   for (int i=1;i<argc;i++)
  2403.     if (!strcmp(argv[i],"-upgrade"))
  2404.     {
  2405.       lisp_init(0xf000,0x30000);
  2406.       char *prog="(load \"lisp/upgrade.lsp\")",*cs;
  2407.       cs=prog;
  2408.       if (!eval(compile(cs)))
  2409.     dprintf("file does not exists : lisp/upgrade.lsp, cannot upgrade\n");
  2410.  
  2411.       exit(0);
  2412.     }        
  2413. }
  2414.  
  2415. void check_for_lisp(int argc, char **argv)
  2416. {
  2417.   for (int i=1;i<argc;i++)
  2418.   {
  2419.     if (!strcmp(argv[i],"-lisp"))
  2420.     {
  2421.       lisp_init(0xf000,0x30000);
  2422.  
  2423. #ifdef __WATCOMC__
  2424.       char *eof_char="CTRL-Z";
  2425. #else
  2426.       char *eof_char="CTRL-D";
  2427. #endif
  2428.       dprintf(
  2429.               " CLIVE (C) 1995 Jonathan Clark, all rights reserved\n"
  2430.               "   (C LISP interpreter and various extentions)\n"
  2431.               "Type (%s) to exit\n",eof_char);
  2432.  
  2433.       while (!feof(stdin))
  2434.       {
  2435.     dprintf("Lisp> ");
  2436.     char *l=get_line(0);
  2437.     char *s=l;
  2438.     while (*s)
  2439.     {
  2440.       void *prog=compile(s);
  2441.       l_user_stack.push(prog);
  2442.       while (*s==' ' || *s=='\t' || *s=='\r' || *s=='\n') s++;
  2443.       lprint(eval(prog));
  2444.       l_user_stack.pop(1);
  2445.     }
  2446.     jfree(l);
  2447.       }      
  2448.  
  2449.       dprintf("End of input : bye\n");
  2450.       exit(0);
  2451.     }
  2452.   }
  2453. }
  2454.  
  2455.  
  2456. void music_check()
  2457. {
  2458.   if (sound_avail&MUSIC_INITIALIZED)
  2459.   {
  2460.     if (current_song && !current_song->playing())
  2461.     {
  2462.       current_song->play();
  2463.       dprintf("song finished\n");
  2464.     }
  2465.     if (!current_song)
  2466.     {
  2467.  
  2468.       current_song=new song("music/intro.hmi");
  2469.       current_song->play(music_volume);
  2470.  
  2471.       /*      if (DEFINEDP(symbol_function(l_next_song)))  // if user function installed, call it to load up next song
  2472.               {
  2473.               int sp=current_space;
  2474.               current_space=PERM_SPACE;
  2475.               eval_function((lisp_symbol *)l_next_song,NULL);
  2476.               current_space=sp;
  2477.               } */
  2478.     } 
  2479.   }
  2480. }
  2481.  
  2482. void setup(int argc, char **argv);
  2483.  
  2484. void share_end();
  2485. void show_end();
  2486.  
  2487. void show_sell(int abortable);
  2488.  
  2489. extern pmenu *dev_menu;
  2490.  
  2491.  
  2492. extern int jmalloc_max_size;
  2493. extern int jmalloc_min_low_size;
  2494.  
  2495. extern int (*verify_file_fun)(char *,char *);
  2496.  
  2497. int registered_ok(char *filename, char *mode)
  2498. {
  2499.   if (registered) return 1;
  2500.  
  2501.   char name[256],*c;
  2502.   c=name;
  2503.   while (*filename) { *c=*(filename++); *c=toupper(*c); c++; } *c=0;
  2504.   if (strstr(name,"REGISTER"))
  2505.     return 0;
  2506.   else return 1;
  2507. }
  2508.  
  2509. void game_net_init(int argc, char **argv)
  2510. {
  2511.   int nonet=!net_init(argc, argv);
  2512.   if (nonet)
  2513.     dprintf("No network driver, or network driver returned failure\n");
  2514.   else 
  2515.   {
  2516.     set_file_opener(open_nfs_file);
  2517.     if (main_net_cfg && main_net_cfg->state==net_configuration::CLIENT)
  2518.     {
  2519.       if (set_file_server(net_server))
  2520.         start_running=1;
  2521.       else
  2522.       {
  2523.         dprintf("Unable to attach to server, quiting\n");
  2524.         exit(0);
  2525.       }
  2526.     } else
  2527.     {
  2528.       int i;
  2529.       for (i=1;i<argc-1;i++)
  2530.         if (!strcmp(argv[i],"-fs"))
  2531.           if (!set_file_server(argv[i+1]))
  2532.             dprintf("could not set defualt file server to %s\n",argv[i+1]);
  2533.     }
  2534.   }    
  2535.  
  2536. }
  2537.  
  2538. #ifdef __MAC__
  2539. //extern int PixMult;
  2540. #if 1
  2541. char cmdline[256];
  2542. #elif 1
  2543. char cmdline[] = "";
  2544. #elif 1
  2545. char cmdline[] = "abuse -server -a deathmat";
  2546. #else
  2547. char cmdline[] = "abuse -net 193.246.40.9";
  2548. #endif
  2549. char delims[] = " ";
  2550. char *tmp_argv[255];
  2551.  
  2552. void GetArgs(int &argc, char **(&argv))
  2553. {
  2554.   char *s;
  2555.  
  2556.   dprintf(    "Usage:\n"
  2557.       "  abuse [-options]\n\n"
  2558.       "  Options:\n"
  2559.       "    -server -a deathmat        become a server for deathmatch game\n"
  2560.       "    -net <dotted ip address>   connect to a server\n\n"
  2561.       "Options for mac:\n"
  2562.       "  Hold down <control> for single pixel mode\n"
  2563.       "  Hold down <option> for edit mode\n"
  2564.       "  Hold down <left shift> for double size mode\n\n"
  2565.       "If started with no command line options, networking will attempt\n"
  2566.       "  to search the local network for servers\n\n"
  2567.                 );
  2568.   dprintf("Enter command line:\n");
  2569.   gets(cmdline);
  2570.     
  2571.   argc = 0;
  2572.   argv = tmp_argv;
  2573.   s = strtok(cmdline, delims);
  2574.   while (s)
  2575.   {
  2576.     argv[argc] = s;
  2577.     argc++;
  2578.     s = strtok(0, delims);
  2579.   }
  2580.   argv[argc] = 0;
  2581. }
  2582.  
  2583. extern void InitMacScreen();
  2584. extern void QuitMacScreen();
  2585.  
  2586. #endif
  2587.  
  2588. int main(int argc, char **argv)
  2589. {
  2590. #ifdef __MAC__
  2591.   InitMacScreen();
  2592. #if 1
  2593.   //    if (!MacMenu())
  2594.   //        return 0;
  2595.  
  2596. #else
  2597.   unsigned char km[16];
  2598.  
  2599.   GetArgs(argc,argv);
  2600.     
  2601.   dprintf("Mac Options: ");
  2602.   GetKeys((unsigned long*)&km);
  2603.   if ((km[ 0x3a >>3] >> (0x3a & 7)) &1 != 0)
  2604.   {
  2605.     dev|=EDIT_MODE;    
  2606.     start_edit=1;
  2607.     start_running=1;
  2608.     disable_autolight=1;
  2609.     dprintf("Edit Mode...");
  2610.   }
  2611.   if ((km[ 0x3b >>3] >> (0x3b & 7)) &1 != 0)
  2612.   {
  2613.     PixMult = 1;
  2614.     dprintf("Single Pixel...");
  2615.   }
  2616.   else
  2617.   {
  2618.     PixMult = 2;
  2619.     dprintf("Double Pixel...");
  2620.   }
  2621.   if ((km[ 0x38 >>3] >> (0x38 & 7)) &1 != 0)
  2622.   {
  2623.     xres *= 2;  yres *= 2;
  2624.     dprintf("Double Size...");
  2625.   }
  2626.   dprintf("\n");
  2627.     
  2628.   if (tcpip.installed())
  2629.     dprintf( "Using %s\n", tcpip.name());
  2630. #endif
  2631. #endif
  2632.  
  2633.   start_argc=argc;
  2634.   start_argv=argv;
  2635.   
  2636.   { for (int i=0;i<argc;i++)
  2637.   {
  2638.     if (!strcmp(argv[i],"-cprint"))
  2639.       external_print=1;
  2640.     if (!strcmp(argv[i],"-min_low"))
  2641.     {
  2642.       i++;
  2643.       jmalloc_min_low_size=atoi(argv[i]);
  2644.     }
  2645.   }
  2646.   }
  2647.  
  2648.   set_dprinter(game_printer);
  2649.   set_dgetter(game_getter);
  2650.   set_no_space_handler(handle_no_space);
  2651.  
  2652.   setup(argc,argv);
  2653.  
  2654.   show_startup();
  2655.  
  2656.   //  jmalloc_max_size=0x150000;
  2657.   jmalloc_init(0x150000); 
  2658.   //  jmalloc_init(100000); 
  2659.  
  2660.   start_sound(argc,argv);
  2661.  
  2662. //#ifdef __MAC__
  2663.   //stat_man=new mac_status_manager();
  2664. //#else
  2665.   stat_man=new text_status_manager();
  2666. //#endif
  2667.   if (!get_option("-no_timer"))
  2668.   {
  2669.     timer_init();
  2670.   }
  2671.  
  2672.  
  2673.   if (!get_option("-share"))
  2674.   {
  2675.     jFILE *fp=new jFILE("register/micron.vcd","rb");
  2676.     if (!fp->open_failure())
  2677.     {
  2678.       spec_directory sd(fp);
  2679.       if (sd.find("Copyright (C) 1995 Crack dot Com, All Rights reserved"))
  2680.         registered=1;
  2681.     }
  2682.     delete fp;
  2683.   }
  2684.  
  2685.   verify_file_fun=registered_ok;
  2686.  
  2687.  
  2688.  
  2689.   jrand_init();
  2690.   jrand();  // so compiler doesn't complain
  2691.  
  2692.  
  2693.   set_spec_main_file("abuse.spe");
  2694.  
  2695.   if (getenv("ABUSE_PATH"))       // look to see if we are supposed to fetch the data elsewhere
  2696.     set_filename_prefix(getenv("ABUSE_PATH"));   
  2697.  
  2698.   if (getenv("ABUSE_SAVE_PATH"))       // look to see if we are supposed to fetch the data elsewhere
  2699.     set_save_filename_prefix(getenv("ABUSE_SAVE_PATH"));   
  2700.  
  2701.   check_for_lisp(argc,argv);
  2702.   check_for_upgrade(argc,argv);
  2703.  
  2704.   set_mode(VMODE_640x480,argc,argv);
  2705.  
  2706.   if (stat_man)
  2707.     delete stat_man;
  2708.   stat_man=new net_status_manager("art/loading.spe",
  2709.       413,428,608,451,
  2710.       54,104);
  2711.  
  2712.  
  2713.  
  2714.   do
  2715.   {
  2716.     if (main_net_cfg) 
  2717.     {
  2718.  
  2719.  
  2720.       if (!main_net_cfg->notify_reset())
  2721.       {
  2722.         if (!get_option("-no_timer"))
  2723.           timer_uninit();
  2724.         sound_uninit();
  2725.         exit(0);
  2726.       }
  2727.     }
  2728.  
  2729.     game_net_init(argc,argv);
  2730.     lisp_init(0x16000,0x94000);
  2731.     //  lisp_init(0x100000,0x10000);
  2732.  
  2733.     dev_init(argc,argv);
  2734.  
  2735.  
  2736.     game *g=new game(argc,argv);
  2737.  
  2738.     delete stat_man;
  2739.     stat_man=new net_status_manager("art/status.spe",
  2740.         295,203,304,366,
  2741.         46,222);
  2742.  
  2743.  
  2744.  
  2745.     dev_cont=new dev_controll();
  2746.     dev_cont->load_stuff();
  2747.  
  2748.  
  2749.  
  2750.     g->get_input();      // prime the net
  2751.  
  2752.     int xx;
  2753.     for (xx=1;xx<argc;xx++)
  2754.       if (!strcmp(argv[xx],"-server"))
  2755.       {
  2756.         xx++;
  2757.         if (!become_server(argv[xx]))
  2758.         {      
  2759.           dprintf("unable to become a server\n");
  2760.           exit(0);
  2761.         }
  2762.         xx=argc+1;
  2763.       }
  2764.  
  2765.     if (main_net_cfg) 
  2766.       wait_min_players();
  2767.  
  2768.     net_send(1);
  2769.     if (net_start())
  2770.     {
  2771.       g->step();                        // process all the objects in the 
  2772.       g->calc_speed();
  2773.       g->update_screen();               // redraw the screen with any changes
  2774.     }
  2775.  
  2776.     while (!g->done())
  2777.     {
  2778.       StartTime(0);//kill me
  2779.         
  2780.       StartTime(1);//kill me
  2781.       //      music_check();
  2782.  
  2783.       if (req_end)
  2784.       {
  2785.         delete current_level;
  2786.         current_level=NULL;
  2787.                 
  2788.         if (!registered)
  2789.           share_end();
  2790.         else show_end();
  2791.             
  2792.         the_game->set_state(MENU_STATE);
  2793.         req_end=0;
  2794.       }
  2795.       
  2796.  
  2797.       if (demo_man.current_state()==demo_manager::NORMAL)
  2798.       {
  2799.         net_receive();
  2800.       }
  2801.  
  2802.       if (req_name[0])            // see if a request for a level load was made during the last tick
  2803.       {
  2804.         //                    ProfilerDump("\pabuse.prof");  //prof    
  2805.         //                    ProfilerTerm();
  2806.         int show;
  2807.         if (!current_level)
  2808.           show=0;
  2809.         else if (strcmp(req_name,current_level->name()) && memcmp(req_name,"save",4)!=0)
  2810.           show=1;
  2811.         else show=0;
  2812.  
  2813.         if (show)
  2814.           show_stats();
  2815.         g->load_level(req_name);
  2816.         switch_mode(VMODE_320x200);
  2817.                recalc_local_view_space();
  2818.         if (show)
  2819.           end_stats();
  2820.  
  2821.         //                    ProfilerInit(collectDetailed, bestTimeBase, 2000, 200); //prof
  2822.         req_name[0]=0;
  2823.         g->draw(g->state==SCENE_STATE);
  2824.       }
  2825.  
  2826.       //    if (demo_man.current_state()!=demo_manager::PLAYING)
  2827.       g->get_input();
  2828.       
  2829.       if (demo_man.current_state()==demo_manager::NORMAL)
  2830.           net_send();
  2831.       else
  2832.           demo_man.do_inputs();
  2833.  
  2834.       service_net_request();
  2835.  
  2836.       DiffTime("  PreStuff",1); //kill me
  2837.       StartTime(2);    //kill me
  2838.             
  2839.       g->step();                        // process all the objects in the 
  2840.  
  2841.       DiffTime("  Step",2);  // kill me
  2842.       StartTime(3);  // kill me
  2843.       server_check();
  2844.  
  2845.       g->calc_speed();
  2846.       DiffTime("  MidStuff",3);  // kill me
  2847.       StartTime(4);  // kill me
  2848.       if (!req_name[0])                // see if a request for a level load was made during the last tick
  2849.         g->update_screen();               // redraw the screen with any changes
  2850.       DiffTime("  Update",4);  // kill me
  2851.  
  2852.       DiffTime("GameLoop",0);
  2853.     }
  2854.       switch_mode(VMODE_640x480);
  2855.     net_uninit();
  2856.  
  2857.     if (net_crcs)
  2858.     {
  2859.       net_crcs->clean_up();
  2860.       delete net_crcs;
  2861.       net_crcs=NULL;
  2862.     }
  2863.  
  2864.     delete chat;
  2865.  
  2866.     if (!registered)
  2867.       show_sell(0);
  2868.     else milli_wait(500);
  2869.  
  2870.  
  2871.     if (small_render) { delete small_render; small_render=NULL; }
  2872.  
  2873.     if (current_song) 
  2874.     { current_song->stop();
  2875.     delete current_song; 
  2876.     current_song=NULL; 
  2877.     }
  2878.  
  2879.  
  2880.     cash.empty();
  2881.  
  2882.  
  2883.     if (dev_console)
  2884.     {
  2885.       delete dev_console;
  2886.       dev_console=NULL;
  2887.     }
  2888.  
  2889.     if (dev_menu)
  2890.     {
  2891.       delete dev_menu;
  2892.       dev_menu=NULL;
  2893.     }
  2894.  
  2895.     delete g;
  2896.     if (old_pal) delete old_pal; old_pal=NULL;
  2897.     compiled_uninit();
  2898.     delete_all_lights();
  2899.     jfree(white_light_initial);
  2900.  
  2901.     for (int i=0;i<TTINTS;i++) jfree(tints[i]);
  2902.  
  2903.  
  2904.     dev_cleanup();
  2905.     delete dev_cont; dev_cont=NULL;
  2906.    
  2907.  
  2908.     if (!(main_net_cfg && main_net_cfg->restart_state()))
  2909.     {
  2910.       void *end_msg=make_find_symbol("end_msg");
  2911.       if (DEFINEDP(symbol_value(end_msg)))
  2912.         dprintf("%s\n",lstring_value(symbol_value(end_msg)));
  2913.     }
  2914.  
  2915.     lisp_uninit();
  2916.     sd_cache.clear();
  2917.  
  2918.     base->packet.packet_reset();
  2919.     mem_report("end.mem");
  2920.   } while (main_net_cfg && main_net_cfg->restart_state());
  2921.  
  2922.    close_graphics();
  2923.  
  2924.   if (main_net_cfg) { delete main_net_cfg; main_net_cfg=NULL; }
  2925.   set_filename_prefix(NULL);  // dealloc this mem if there was any
  2926.   set_save_filename_prefix(NULL);
  2927.  
  2928.   if (!get_option("-no_timer"))
  2929.     timer_uninit();
  2930.  
  2931.   mem_report("end.mem");
  2932.   jmalloc_uninit();
  2933.   l_user_stack.clean_up();
  2934.   l_ptr_stack.clean_up();
  2935.  
  2936.   sound_uninit();
  2937.  
  2938. #ifdef __MAC__
  2939.   QuitMacScreen();
  2940. #endif
  2941.  
  2942.   exit(0);
  2943.  
  2944.   return 0;  
  2945. }
  2946.  
  2947.